Instrucciones de implementación
1. Agregue un contador de referencia al objeto. El valor del contador de referencia aumentará cada vez en algún lugar. Siempre que una referencia deja de ser válida, el contador se reduce en uno.
Si el recuento del valor de la variable se reduce en uno y es igual a 0, el valor se liberará y no será basura. El recolector de basura no lo maneja.
Si el recuento del valor de la variable es mayor que 0 después de reducirlo en uno, el valor se considera irrealizable y puede convertirse en basura.
2. El recolector de basura recolecta la posible basura. Después de alcanzar una cierta cantidad, inicia el programa de identificación de basura y libera la basura real.
Ejemplo
<?php
// Caso del mecanismo de recolección de basura de PHP: consulte el manual de php
//--------------------Tipo escalar--------------------
// consejo: cada variable PHP existe en un contenedor de variables llamado "zval", que contiene el tipo y valor de la variable, "is_ref": si es una variable de referencia, "refcount": recuento de referencias
// ex: Generar un nuevo contenedor zval $a = 'nueva cadena';
// ex: muestra información del contenedor zval xdebug_debug_zval('a'); // a: (refcount=1, is_ref=0),string 'nueva cadena' (longitud=10)
// ej: aumentar el recuento de referencias del contenedor zval $c = $b = $a;
xdebug_debug_zval('a'); // a:(refcount=3, is_ref=0),cadena 'nueva cadena' (longitud=10)
xdebug_debug_zval('b'); // b:(refcount=3, is_ref=0),cadena 'nueva cadena' (longitud=10)
xdebug_debug_zval('c'); // c:(refcount=3, is_ref=0),cadena 'nueva cadena' (longitud=10)
// consejo: solo hay un contenedor en este momento, porque PHP no copiará el contenedor de variables generado cuando no sea necesario // En este momento, este contenedor de variables está asociado con la variable a, la variable by la variable c.
unset($b); // ex: reducir el recuento de referencias xdebug_debug_zval('a'); // a:(refcount=2, is_ref=0),string 'nueva cadena' (longitud=10)
// consejo: unset Al eliminar una variable, el recuento de la variable refcount se reduce en uno. En este momento, solo $a y $b apuntan al contenedor de variables.
desarmado ($a);
desarmado ($c);
var_dump ($a);
// consejo: en este momento, el recuento es 0 y la variable se elimina // Cuando el recuento llega a 0, el contenedor de variables que contiene el tipo y el valor se eliminará de la memoria.
//--------------------Tipo compuesto-------------
echo '--------------Tipo compuesto------------<br/>';
$a = matriz(
'nombre' => 'junior',
'edad' => 18
);
xdebug_debug_zval('a');
// a:(refcount=1, is_ref=0),
// matriz (tamaño=2)
// 'nombre' => (refcount=1, is_ref=0),cadena 'junior' (longitud=6)
// 'edad' => (refcount=1, is_ref=0),int 18
// ex: Agregar un elemento existente a la matriz $a['love'] = $a['name'];
xdebug_debug_zval('a');
// a:(refcount=1, is_ref=0),
// matriz (tamaño=3)
// 'nombre' => (refcount=2, is_ref=0),cadena 'junior' (longitud=6)
// 'edad' => (refcount=1, is_ref=0),int 18
// 'amor' => (refcount=2, is_ref=0),cadena 'junior' (longitud=6)
// $a = matriz('uno');
// xdebug_debug_zval('a');
// // $b = &$a;
// $c = $a;
// $b = &$c;
// xdebug_debug_zval('b');
// xdebug_debug_zval('c');
// xdebug_debug_zval('a');
// Limpiar el problema del contenedor de variables echo '------------Problema de pérdida de memoria-----------<br/>';
$a = matriz('uno');
xdebug_debug_zval('a');
// a:(refcount=1, is_ref=0),
// matriz (tamaño=1)
// 0 => (refcount=1, is_ref=0),cadena 'uno' (longitud=3)
$a[] = &$a;
xdebug_debug_zval('a');
// a:(refcount=2, is_ref=1),
// matriz (tamaño=2)
// 0 => (refcount=1, is_ref=0),cadena 'uno' (longitud=3)
// 1 => (refcount=2, is_ref=1),
// &matriz
// desarmado ($a);
// (refcount=1, is_ref=1)=matriz (
// 0 => (refcount=1, is_ref=0)='uno',
// 1 => (refcount=1, is_ref=1)=...
// )
// consejo: después de unset($a), el recuento de referencias se reduce en uno, aunque ya no haya ningún símbolo en un ámbito que apunte a esta estructura (es decir, el contenedor de variables),
// Dado que el elemento de matriz "1" todavía apunta a la matriz misma, este contenedor no se puede borrar // Dado que no hay ningún otro símbolo que apunte a él, el usuario no tiene forma de borrar esta estructura, lo que resulta en una pérdida de memoria // Afortunadamente , PHP Esta estructura de datos se borrará al final de la ejecución del script, pero se consumirá mucha memoria antes de que PHP la borre.
// Lo mismo sucede con los objetos, de hecho es más probable que suceda con los objetos porque los objetos siempre están referenciados implícitamente.Lo anterior es cómo el recuento de referencias de PHP implementa la recolección de basura. Espero que sea útil para todos.