¿Para qué sirve la tabla débil de Lua?
Casi todos los lenguajes de scripting tienen recolectores de basura (GC), y Lua también.
No importa si no entiendes GC. Déjame explicarte:
Todo comienza con el lenguaje C, el creador de los lenguajes de programación modernos.
Si desea utilizar variables en C, puede definir variables como esta, por ejemplo:
-
void hello(){
int a = 0; // Declaración de variable local
}
-
Se ha determinado la vida y muerte de la variable local A, es decir , entre {paréntesis y} paréntesis entre.
Esto será más seguro, porque la pila se borrará (borrará las variables) después de ejecutar la función, por lo que no es necesario considerar la vida o muerte de las variables, pero no es lo suficientemente flexible. porque su alcance está limitado y solo se puede usar aquí en la función.
En otras palabras, defina las variables globales de la siguiente manera:
-
Static int a = 0 //Declaración de variable global
void hola1(){
a = 1;
}
void hola2(){
a = 2;
}
-
Obviamente esto es muy flexible y se puede usar en cualquier lugar.
Pero ahora que ha nacido, no terminará hasta que acabe el espectáculo.
Esto significa que mientras el programa se esté ejecutando, seguirá existiendo de todos modos.
Te enfrentarás a una eterna variable. Si defines 10, 100, 1000... esto será un montón de... (¿zombis?)
Esto no es bueno. No puedes controlar la vida y la muerte de las variables, y no puedes lograrlo. El propósito de manejar de manera flexible la vida y la muerte de las variables.
¿Quieres controlar tú mismo la vida y la muerte de las variables? c proporciona una función para realizar su sueño: malloc, de la siguiente manera:
-
int * p = (int *) malloc (sizeof (int)); // Crear manualmente - Estudiante
De esta manera, P almacena la primera dirección de la memoria que se ha solicitado y ya se puede utilizar, de la siguiente manera:
* p = 1;
Cuando ya no uses esta memoria, entonces usas la función gratuita para liberarla (limpiarla); de lo contrario, siempre existirá.
Gratis (p); //Liberación manual-Muerte
-
Si no haces esto, la memoria seguirá creciendo hasta que el programa falle. (el mundo caerá en la confusión).
De esta manera, el tercer método es bueno y flexible, pero una vez que defines más variables de este tipo, te conviertes en un dios: debes gestionar la vida y la muerte de cada variable, incluso si es 1, 10. , 100, 1000. No puedes perderte ninguno de ellos, de lo contrario se alterará el equilibrio del mundo (algunas personas no morirán), en otras palabras, tu programa fallará.
Parece obvio que no a todo el mundo le gusta o puede ser un dios. En este caso, sale algo: ¡GC!
Es el salvador de este problema, los detalles son los siguientes:
Recolección de Basura - Recolector de Basura
Su función es que puedes definir variables a tu antojo , te seguiré. Solo necesitas definir el nacimiento de la variable y yo seré responsable de la muerte de la variable.
Entonces preguntas casualmente: ¿Cómo sabes que no necesito esta variable?
Entonces el problema es más complicado. Actualmente, existen muchas implementaciones de GC. Sólo conozco el argumento GC. Hablemos primero con Lua.
En primer lugar, en los lenguajes de scripting, las variables se declaran utilizando el tercer método mencionado anteriormente: malloc crea manualmente bloques de memoria.
Código Lua:
-
Prueba funcional()
Local a = { x = 1 } - GC dará manual; El bloque de memoria creado "{x=1}" agrega una referencia -b con el número de referencia 1.
End
test(); - Después de ejecutar la función, se borra la pila y se borra la variable local A.
GC reducirá la memoria de "{x=1}" en una referencia. Cuando el número de referencia es 0, GC borrará la memoria de "{x=1}".
Imprimir (una copia); - cero
-
Consulte lo siguiente:
-
b = 0; - variable externa
Prueba funcional()
Local a = { x = 1};
b = a - GC estará en; memoria Agregue otra referencia -a a "{x=1}", con el número de referencia 2.
End
test(); una vez ejecutada la función, borra la pila. El número de referencia de la memoria "{x=1}" se reduce en 1, quedando 1, por lo que no es necesario borrar este bloque de memoria.
Print (b); -Form:003BAAD8
-
Deberías saber aproximadamente cómo funciona GC en el ejemplo anterior. Veamos el enfoque del artículo anterior: la tabla Lua-débil.
Cualquier referencia a un bloque de memoria en Lua aumentará el número de referencia en 1, con una excepción: una tabla débil, cuya referencia al bloque de memoria no aumentará el número de referencia en 1.
Mire el siguiente código:
-
a = { }
b = { }
;setmetatable(a, b); - Establece a como una tabla débil.
b._ _ mode = ' k
key = { }; - Añade una referencia al bloque-clave de memoria "{}", con el número de referencia 1.
a[key]= 1; - Las referencias de tabla débiles no agregan parámetros, por lo que los parámetros del bloque de memoria "{}" siguen siendo 1.
Clave = {}: cambie la clave para que apunte al bloque de memoria "{}" recién agregado y el argumento del bloque de memoria "{}" anterior se reduce de uno a 0.
a[key]= 2 - Igual que el anterior.
Recoger basura(): llama a GC para borrar la memoria sin referencia en tablas débiles.
Haga el par k y v (a)
Imprima (v); solo genere un 2.
Fin
-
Si A no es una tabla débil sino una tabla normal, entonces A agregará 1 a la variable independiente de "{}" bloque de memoria.
Elimine "b.__mode='k" en esta oración y verá el resultado de 1 y 2.
Mira el último ejemplo:
-
a = {}
b = {}
setmetatable (a, b)
b.__mode = "k "
Prueba funcional()
Clave local 1 = { };
a[clave 1]= 1;
Clave local 2 = { };
a[clave 2]= 2;
Fin
test(); -key1 y key2 apuntan a las variables independientes del bloque de memoria después de ejecutar la función, y las variables independientes se reducen de uno a cero.
Collectgarbage() - para que todo se borre.
Haga el par k y v (a)
Imprima (v); no hay salida.
Fin
-
Lo anterior es mi propia comprensión de gc (sin verificar la información), solo como referencia. ...
Posdata: Aunque GC es un salvador, no es un salvador omnipotente. Las variables de reciclaje tienen problemas como la eficiencia y las referencias circulares, a los que es necesario prestar atención. ...