Python Language
Raccolta dei rifiuti

Osservazioni

/* 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;

Conteggio di riferimento

La maggior parte della gestione della memoria di Python viene gestita con il conteggio dei riferimenti.

Ogni volta che un oggetto viene referenziato (ad es. Assegnato a una variabile), il suo conteggio dei riferimenti viene automaticamente aumentato. Quando è dereferenziato (ad es. La variabile esce dal campo di applicazione), il suo conteggio di riferimento viene automaticamente diminuito.

Quando il conteggio dei riferimenti raggiunge lo zero, l'oggetto viene immediatamente distrutto e la memoria viene immediatamente liberata. Pertanto, per la maggior parte dei casi, il garbage collector non è nemmeno necessario.

>>> 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

Per dimostrare ulteriormente il concetto di riferimenti:

>>> 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

Garbage Collector per cicli di riferimento

L'unica volta che è necessario il garbage collector è se si dispone di un ciclo di riferimento . L'esempio semplice di un ciclo di riferimento è uno in cui A si riferisce a B e B si riferisce ad A, mentre nient'altro si riferisce ad A o B. Né A né B sono accessibili da qualsiasi parte del programma, quindi possono essere distrutti in modo sicuro, tuttavia i loro conteggi di riferimento sono 1 e quindi non possono essere liberati solo dall'algoritmo di conteggio di riferimento.

>>> 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 di riferimento può essere arbitrario. Se A punta a B punta a C punta a ... punta a Z che punta ad A, quindi non verranno collezionate da A a Z, fino alla fase di garbage collection:

>>> 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

Effetti del comando

Rimozione di un nome di variabile dall'ambito usando del v , o rimozione di un oggetto da una raccolta usando del v[item] o del[i:j] , o rimuovendo un attributo usando del v.name , o qualsiasi altro modo di rimuovere riferimenti a un oggetto, non innesca alcuna chiamata distruttore o alcuna memoria liberata in sé e per sé. Gli oggetti vengono distrutti solo quando il loro conteggio dei riferimenti raggiunge lo zero.

>>> 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

Riutilizzo di oggetti primitivi

Una cosa interessante da notare, che può aiutare a ottimizzare le tue applicazioni, è che anche le primitive vengono effettivamente riconquistate. Diamo un'occhiata ai numeri; per tutti gli interi compresi tra -5 e 256, Python riutilizza sempre lo stesso oggetto:

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

Si noti che il Refcount aumenta, il che significa che a e b riferimento allo stesso oggetto sottostante quando si riferiscono alla primitiva 1 . Tuttavia, per numeri più grandi, Python in realtà non riutilizza l'oggetto sottostante:

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

Poiché il refcount per 999999999 non cambia durante l'assegnazione ad a e b possiamo dedurre che si riferiscono a due diversi oggetti sottostanti, anche se entrambi viene assegnato lo stesso primitivo.

Visualizzazione del conto di un oggetto

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

Disabilitare forzatamente gli oggetti

Puoi forzare gli oggetti deallocate anche se il loro refcount non è 0 in entrambi Python 2 e 3.

Entrambe le versioni usano il modulo ctypes per farlo.

ATTENZIONE: facendo questo lascerà il vostro ambiente Python instabile e soggetto a crash senza un traceback! L'utilizzo di questo metodo potrebbe anche introdurre problemi di sicurezza (alquanto improbabili) Distribuisci solo gli oggetti di cui sei sicuro di non fare mai più riferimento. Mai.

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

Dopo l'esecuzione, qualsiasi riferimento all'oggetto now deallocated farà sì che Python produca un comportamento non definito o crash - senza un traceback. C'era probabilmente una ragione per cui il garbage collector non ha rimosso quell'oggetto ...

Se deallocate None , viene visualizzato un messaggio speciale Fatal Python error: deallocating None prima dell'arresto anomalo.

Gestire la garbage collection

Esistono due approcci per influenzare quando viene eseguita una pulizia della memoria. Stanno influenzando la frequenza con cui viene eseguito il processo automatico e l'altro sta attivando manualmente una pulizia.

Il garbage collector può essere manipolato sintonizzando le soglie di raccolta che influiscono sulla frequenza di esecuzione del collector. Python utilizza un sistema di gestione della memoria basato sulla generazione. I nuovi oggetti vengono salvati nella nuova generazione - generazione0 e con ciascuna raccolta sopravvissuta, gli oggetti vengono promossi alle generazioni precedenti. Dopo aver raggiunto l'ultima generazione - generazione2 , non vengono più promossi.

Le soglie possono essere modificate utilizzando il seguente snippet:

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

Il primo argomento rappresenta la soglia per la raccolta di generazione0 . Ogni volta che il numero di allocazioni supera il numero di deallocazioni per 1000, verrà chiamato il garbage collector.

Le generazioni precedenti non vengono pulite ad ogni analisi per ottimizzare il processo. Il secondo e il terzo argomento sono facoltativi e controllano la frequenza con cui vengono pulite le generazioni precedenti. Se la generazione0 è stata elaborata 100 volte senza eseguire la pulizia di generation1 , verrà generata la generazione1 . Allo stesso modo, gli oggetti in generation2 verranno elaborati solo quando quelli in generation1 sono stati puliti 10 volte senza toccare generation2 .

Un'istanza in cui l'impostazione manuale delle soglie è vantaggiosa è quando il programma assegna un sacco di piccoli oggetti senza deallocarli che conduce troppo spesso al garbage collector (ogni allocazione di oggetto generation0_threshold ). Anche se il collezionista è piuttosto veloce, quando gira su un numero enorme di oggetti pone un problema di prestazioni. In ogni caso, non esiste una taglia adatta a tutte le strategie per la scelta delle soglie e il suo caso d'uso è affidabile.

L'attivazione manuale di una raccolta può essere eseguita come nel seguente snippet:

import gc
gc.collect()

La garbage collection viene automaticamente attivata in base al numero di allocazioni e deallocazioni, non sulla memoria consumata o disponibile. Di conseguenza, quando si lavora con oggetti di grandi dimensioni, la memoria potrebbe esaurirsi prima che venga avviata la pulizia automatica. Questo è un buon caso d'uso per chiamare manualmente il garbage collector.

Anche se è possibile, non è una pratica incoraggiata. Evitare perdite di memoria è l'opzione migliore. Ad ogni modo, nei grandi progetti l'individuazione della perdita di memoria può essere un compito ben preciso e l'attivazione manuale di una garbage collection può essere utilizzata come soluzione rapida fino a un ulteriore debugging.

Per i programmi con esecuzione prolungata, la garbage collection può essere attivata su base temporale o su base evento. Un esempio per il primo è un server Web che attiva una raccolta dopo un numero fisso di richieste. Per il futuro, un server Web che attiva una garbage collection quando viene ricevuto un determinato tipo di richiesta.

Non aspettare che la garbage collection sia pulita

Il fatto che la raccolta dei dati inutili venga eliminata non significa che è necessario attendere il ciclo di raccolta dei dati inutili per eseguire la pulizia.

In particolare, non è necessario attendere la garbage collection per chiudere handle di file, connessioni database e connessioni di rete aperte.

per esempio:

Nel seguente codice, si presuppone che il file verrà chiuso nel ciclo di garbage collection successivo, se f è l'ultimo riferimento al file.

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

Un modo più esplicito per ripulire è chiamare f.close() . Puoi farlo ancora più elegante, utilizzando l'istruzione with , anche conosciuta come context manager :

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

L'istruzione with consente di indentare il codice sotto il file aperto. Ciò rende esplicito e più facile vedere per quanto tempo un file viene tenuto aperto. Inoltre, chiude sempre un file, anche se viene sollevata un'eccezione nel blocco while .