Python Language
Recolección de basura

Observaciones

/* Break reference cycles by clearing the containers involved.  This is
 * tricky business as the lists can be changing and we don't know which
 * objects may be freed.  It is possible I screwed something up here.
 */
static void
delete_garbage(PyGC_Head *collectable, PyGC_Head *old)

class A(object):
    def __init__(self, b=None):
        self.b = b
 
    def __del__(self):
        print("We're deleting an instance of A containing:", self.b)
     
class B(object):
    def __init__(self, a=None):
        self.a = a
 
    def __del__(self):
        print("We're deleting an instance of B containing:", self.a)

/* list of uncollectable objects */
static PyObject *garbage = NULL;

Recuento de referencias

La gran mayoría de la administración de memoria de Python se maneja con conteo de referencias.

Cada vez que se hace referencia a un objeto (por ejemplo, asignado a una variable), su recuento de referencia aumenta automáticamente. Cuando se elimina la referencia (por ejemplo, la variable queda fuera del alcance), su recuento de referencia se reduce automáticamente.

Cuando el recuento de referencia llega a cero, el objeto se destruye inmediatamente y la memoria se libera inmediatamente. Por lo tanto, para la mayoría de los casos, el recolector de basura ni siquiera es necesario.

>>> import gc; gc.disable()  # disable garbage collector
>>> class Track:
        def __init__(self):
            print("Initialized")
        def __del__(self):
            print("Destructed")
>>> def foo():
        Track()
        # destructed immediately since no longer has any references
        print("---")
        t = Track()
        # variable is referenced, so it's not destructed yet
        print("---")
        # variable is destructed when function exits
>>> foo()
Initialized
Destructed
---
Initialized
---
Destructed

Para demostrar aún más el concepto de referencias:

>>> def bar():
        return Track()
>>> t = bar()
Initialized
>>> another_t = t  # assign another reference
>>> print("...")
...
>>> t = None          # not destructed yet - another_t still refers to it
>>> another_t = None  # final reference gone, object is destructed
Destructed

Recolector de basura para ciclos de referencia

La única vez que se necesita el recolector de basura es si tiene un ciclo de referencia . El ejemplo simple de un ciclo de referencia es uno en el que A se refiere a B y B se refiere a A, mientras que nada más se refiere a A o B. No se puede acceder a A ni a B desde cualquier lugar del programa, por lo que se pueden destruir de forma segura. sin embargo, sus recuentos de referencia son 1 y, por lo tanto, no se pueden liberar únicamente con el algoritmo de recuento de referencia.

>>> import gc; gc.disable()  # disable garbage collector
>>> class Track:
        def __init__(self):
            print("Initialized")
        def __del__(self):
            print("Destructed")
>>> A = Track()
Initialized
>>> B = Track()
Initialized
>>> A.other = B
>>> B.other = A
>>> del A; del B  # objects are not destructed due to reference cycle
>>> gc.collect()  # trigger collection
Destructed
Destructed
4

Un ciclo de referencia puede ser arbitrario largo. Si A apunta a B apunta a C apunta a ... apunta a Z que apunta a A, entonces no se recolectarán A a Z, hasta la fase de recolección de basura:

>>> objs = [Track() for _ in range(10)]
Initialized
Initialized
Initialized
Initialized
Initialized
Initialized
Initialized
Initialized
Initialized
Initialized
>>> for i in range(len(objs)-1):
...     objs[i].other = objs[i + 1]
...
>>> objs[-1].other = objs[0]  # complete the cycle
>>> del objs                  # no one can refer to objs now - still not destructed
>>> gc.collect()
Destructed
Destructed
Destructed
Destructed
Destructed
Destructed
Destructed
Destructed
Destructed
Destructed
20

Efectos del comando del

Eliminar un nombre de variable del ámbito usando del v , o eliminar un objeto de una colección usando del v[item] o del[i:j] , o eliminar un atributo usando del v.name , o cualquier otra forma de eliminar referencias a un objeto, no desencadena ninguna llamada de destructor ni ninguna memoria liberada en sí misma. Los objetos solo se destruyen cuando su cuenta de referencia llega a cero.

>>> import gc
>>> gc.disable()  # disable garbage collector
>>> class Track:
        def __init__(self):
            print("Initialized")
        def __del__(self):
            print("Destructed")
>>> def bar():
    return Track()
>>> t = bar()
Initialized
>>> another_t = t  # assign another reference
>>> print("...")
...
>>> del t          # not destructed yet - another_t still refers to it
>>> del another_t  # final reference gone, object is destructed
Destructed

Reutilización de objetos primitivos.

Una cosa interesante a tener en cuenta que puede ayudar a optimizar sus aplicaciones es que las primitivas también se vuelven a contar bajo el capó. Echemos un vistazo a los números; para todos los enteros entre -5 y 256, Python siempre reutiliza el mismo objeto:

>>> import sys
>>> sys.getrefcount(1)
797
>>> a = 1
>>> b = 1
>>> sys.getrefcount(1)
799

Tenga en cuenta que refcount aumenta, lo que significa que a y b referencia al mismo objeto subyacente cuando se refieren a la primitiva 1 . Sin embargo, para números más grandes, Python en realidad no reutiliza el objeto subyacente:

>>> a = 999999999
>>> sys.getrefcount(999999999)
3
>>> b = 999999999
>>> sys.getrefcount(999999999)
3

Debido a que el refcount de 999999999 no cambia cuando se asigna a a y b se puede inferir que se refieren a dos objetos subyacentes diferentes, aunque ambos se les asigna el mismo primitivo.

Viendo el refcount de un objeto

>>> import sys
>>> a = object()
>>> sys.getrefcount(a)
2
>>> b = a
>>> sys.getrefcount(a)
3
>>> del b
>>> sys.getrefcount(a)
2

Forzar la desasignación de objetos.

Puede forzar la desasignación de objetos incluso si su refcount no es 0 en Python 2 y 3.

Ambas versiones utilizan el módulo ctypes para hacerlo.

ADVERTENCIA: haciendo esto dejará su entorno Python inestable y propenso a estrellarse sin un rastreo! El uso de este método también podría introducir problemas de seguridad (bastante improbable). Desasigne solo los objetos que está seguro de que nunca volverá a hacer referencia. Siempre.

import ctypes
deallocated = 12345
ctypes.pythonapi._Py_Dealloc(ctypes.py_object(deallocated))

import ctypes, sys
deallocated = 12345
(ctypes.c_char * sys.getsizeof(deallocated)).from_address(id(deallocated))[:4] = '\x00' * 4

Después de ejecutar, cualquier referencia al objeto ahora desasignado hará que Python produzca un comportamiento indefinido o se bloquee, sin un rastreo. Probablemente hubo una razón por la que el recolector de basura no eliminó ese objeto ...

Si desasigna None , aparece un mensaje especial: Fatal Python error: deallocating None antes de que se bloquee.

Gestionando la recogida de basura.

Hay dos enfoques para influir cuando se realiza una limpieza de memoria. Influyen en la frecuencia con la que se realiza el proceso automático y el otro está activando manualmente una limpieza.

El recolector de basura se puede manipular ajustando los umbrales de recolección que afectan la frecuencia a la que se ejecuta el recolector. Python utiliza un sistema de gestión de memoria basado en la generación. Los nuevos objetos se guardan en la generación más nueva - generación0 y con cada colección sobrevivida, los objetos se promueven a las generaciones anteriores. Después de llegar a la última generación - generación2 , ya no se promocionan.

Los umbrales se pueden cambiar usando el siguiente fragmento de código:

import gc
gc.set_threshold(1000, 100, 10) # Values are just for demonstration purpose

El primer argumento representa el umbral para recolectar generation0 . Cada vez que el número de asignaciones supera el número de desasignaciones por 1000, se llamará al recolector de basura.

Las generaciones anteriores no se limpian en cada ejecución para optimizar el proceso. El segundo y tercer argumento son opcionales y controlan la frecuencia con la que se limpian las generaciones anteriores. Si la generación0 se procesó 100 veces sin limpiar la generación1 , entonces se procesará la generación1 . De manera similar, los objetos en la generación 2 se procesarán solo cuando los de la generación 1 se hayan limpiado 10 veces sin tocar la generación 2 .

Una instancia en la que es beneficioso establecer manualmente los umbrales es cuando el programa asigna una gran cantidad de objetos pequeños sin desasignarlos, lo que hace que el recolector de basura se ejecute con demasiada frecuencia (cada una de las asignaciones de objetos de umbral de generación ). A pesar de que el colector es bastante rápido, cuando se ejecuta en una gran cantidad de objetos plantea un problema de rendimiento. De todos modos, no hay una estrategia única para todos los límites para elegir los umbrales y es confiable en cada caso de uso.

La activación manual de una colección se puede hacer como en el siguiente fragmento de código:

import gc
gc.collect()

La recolección de basura se activa automáticamente en función del número de asignaciones y desasignaciones, no en la memoria consumida o disponible. En consecuencia, cuando se trabaja con objetos grandes, la memoria puede agotarse antes de que se active la limpieza automática. Esto es un buen caso de uso para llamar manualmente al recolector de basura.

Aunque es posible, no es una práctica recomendada. Evitar las pérdidas de memoria es la mejor opción. De todos modos, en grandes proyectos, detectar la pérdida de memoria puede ser una tarea fácil y activar manualmente una recolección de basura se puede usar como una solución rápida hasta una depuración adicional.

Para los programas de larga duración, la recolección de basura puede activarse en una base de tiempo o evento. Un ejemplo para el primero es un servidor web que activa una colección después de un número fijo de solicitudes. Para más adelante, un servidor web que activa una recolección de basura cuando se recibe un cierto tipo de solicitud.

No espere a que la recolección de basura se limpie

El hecho de que la recolección de basura se limpie no significa que deba esperar a que se limpie el ciclo de recolección de basura.

En particular, no debe esperar a que la recolección de basura cierre los manejadores de archivos, las conexiones de base de datos y las conexiones de red abiertas.

por ejemplo:

En el siguiente código, asume que el archivo se cerrará en el siguiente ciclo de recolección de basura, si f fue la última referencia al archivo.

>>> f = open("test.txt")
>>> del f

Una forma más explícita de limpiar es llamar a f.close() . Puede hacerlo aún más elegante, es decir, utilizando la instrucción with , también conocida como administrador de contexto :

>>> with open("test.txt") as f:
...     pass
...     # do something with f
>>> #now the f object still exists, but it is closed

La instrucción with permite sangrar su código debajo del archivo abierto. Esto hace que sea explícito y más fácil ver cuánto tiempo se mantiene abierto un archivo. También siempre cierra un archivo, incluso si se produce una excepción en el bloque while .