Garbage Collection in Python: concetti chiave e meccanismi

La gestione della memoria è un aspetto importante ma spesso trascurato della programmazione. Se non gestita correttamente, può causare applicazioni lente, crash inaspettati o addirittura memory leak. Fortunatamente, Python se ne occupa tramite un processo noto come garbage collection, un sistema integrato che gestisce automaticamente la memoria.

Ma come funziona la garbage collection di Python e perché dovrebbe importarti? Capire questo processo è fondamentale per scrivere codice efficiente e senza bug, che offra buone prestazioni anche quando i tuoi progetti diventano più complessi.

Alla fine di questo articolo conoscerai le basi della garbage collection in Python e perché è importante, capirai come Python utilizza il reference counting e la garbage collection generazionale per gestire la memoria e imparerai alcuni consigli per evitare i memory leak. Ti invito anche a iscriverti al nostro corso Writing Efficient Python Code, che ti insegnerà come allocare le risorse nel tuo ambiente e valutare gli overhead, temi più ampi di cui la garbage collection è solo una parte.

Che cos'è la Garbage Collection in Python?

La garbage collection è il modo in cui Python gestisce automaticamente la memoria, garantendo che le tue applicazioni funzionino senza intoppi liberando la memoria che non è più in uso. In parole semplici, è come avere un bidello invisibile che pulisce dopo il tuo codice, eliminando gli oggetti che non servono più.

“Python che raccoglie la spazzatura.” Immagine di Dall-E 2

Perché abbiamo bisogno della garbage collection in Python?

In qualsiasi applicazione, gli oggetti vengono creati per memorizzare dati, eseguire calcoli o gestire attività. Tuttavia, una volta che questi oggetti hanno esaurito il loro scopo, continuano a occupare spazio in memoria finché non vengono rimossi esplicitamente. Se questi oggetti inutilizzati si accumulano, possono portare l'applicazione a usare più memoria del necessario, causando prestazioni peggiori e possibili crash.

La garbage collection evita questi scenari. Rileva automaticamente quando un oggetto non è più necessario (nessuna parte del tuo codice lo referenzia) e poi lo rimuove in sicurezza dalla memoria. Questo processo aiuta a:

• Prevenire i memory leak: pulendo automaticamente gli oggetti inutilizzati, la garbage collection riduce il rischio di memory leak, cioè quando la memoria non più necessaria non viene rilasciata.
• Ottimizzare le prestazioni: liberando memoria, la garbage collection aiuta a mantenere le prestazioni della tua applicazione, soprattutto nei programmi a lunga esecuzione o in quelli che gestiscono grandi quantità di dati.
• Semplificare lo sviluppo: poiché Python gestisce automaticamente la memoria, gli sviluppatori possono concentrarsi sullo scrivere codice invece che sulla gestione della memoria.

Come Python implementa automaticamente la Garbage Collection

La garbage collection di Python è un sistema complesso progettato per gestire automaticamente la memoria, permettendo agli sviluppatori di concentrarsi sul codice anziché sulla gestione della memoria. Python utilizza principalmente due meccanismi per implementare la garbage collection: reference counting e garbage collection generazionale. Questi meccanismi lavorano insieme per garantire una gestione efficiente della memoria, riducendo al minimo le probabilità di memory leak e ottimizzando le prestazioni della tua applicazione.

Prima di approfondire questi meccanismi, è importante notare che questo processo di garbage collection è particolarmente rilevante per CPython, l'implementazione di Python più utilizzata. Sebbene altre implementazioni come PyPy o Jython possano gestire la garbage collection in modo diverso, CPython si affida fortemente a questi due metodi per mantenere le tue applicazioni fluide.

Reference counting

Il reference counting è il metodo fondamentale che Python utilizza per gestire la memoria. In sostanza, il reference counting tiene traccia del numero di riferimenti (o puntatori) a un oggetto in memoria. Ogni volta che viene creato un nuovo riferimento a un oggetto, Python aumenta il contatore di riferimenti di quell'oggetto. Al contrario, quando un riferimento viene rimosso o esce dallo scope, Python diminuisce il contatore. Ecco come funziona:

• Tracciamento dei riferimenti: ogni oggetto in Python ha un contatore di riferimenti, aggiornato ogni volta che l'oggetto viene referenziato o dereferenziato. Ad esempio, assegnare un oggetto a una variabile o passarlo a una funzione aumenta il contatore; eliminare la variabile lo diminuisce.
• Deallocazione della memoria: quando il contatore di un oggetto scende a zero, cioè nessuna parte del tuo codice usa più l'oggetto, Python dealloca automaticamente la memoria che occupa.

Nonostante l'efficienza, il reference counting ha dei limiti. Il più significativo è l'incapacità di gestire le riferimenti ciclici, che si verificano quando due o più oggetti si referenziano a vicenda formando un ciclo. In questi casi, i contatori non arrivano mai a zero, impedendo il recupero della memoria. Qui entra in gioco la garbage collection generazionale.

Garbage collection generazionale

Per superare i limiti del reference counting, Python impiega anche la garbage collection generazionale. Questo metodo avanzato è progettato per gestire i riferimenti ciclici e migliorare l'efficienza della gestione della memoria. L'idea alla base della garbage collection generazionale si basa sull'osservazione che la maggior parte degli oggetti è o di breve durata (temporanei) o di lunga durata (persistenti). Categorizzando gli oggetti in base alla loro età, Python ottimizza il processo di raccolta. Ecco come funziona la garbage collection generazionale:

• Generazioni: il garbage collector di Python organizza gli oggetti in tre generazioni: Generazione 0 (la più giovane), Generazione 1 (mezza età) e Generazione 2 (la più vecchia). I nuovi oggetti vengono inseriti nella Generazione 0 e, se sopravvivono alla raccolta, passano alla generazione successiva.

• Priorità agli oggetti giovani: il garbage collector viene eseguito più spesso sugli oggetti giovani (Generazione 0) perché è più probabile che diventino presto inutilizzati. Con l'invecchiamento e il passaggio alle generazioni superiori, gli oggetti vengono raccolti meno frequentemente. Questo approccio riduce l'overhead concentrandosi sugli oggetti che probabilmente verranno scartati a breve.

• Gestione dei riferimenti ciclici: la garbage collection generazionale è particolarmente efficace nell'identificare e raccogliere oggetti coinvolti in riferimenti ciclici. Durante il processo di raccolta, il garbage collector di Python può rilevare questi cicli e recuperare la memoria, prevenendo i memory leak causati da riferimenti ciclici.

Come puoi attivare manualmente la Garbage Collection di Python 

Sebbene il sistema di garbage collection di Python sia progettato per gestire automaticamente la memoria, ci sono situazioni in cui la gestione manuale può essere utile. Vediamo come.

Avviare la garbage collection in Python

Nella maggior parte dei casi, il garbage collector di Python viene eseguito automaticamente, ripulendo gli oggetti inutilizzati senza alcun intervento. Tuttavia, ci sono situazioni in cui potresti voler attivare manualmente la garbage collection per liberare memoria. Ciò è particolarmente utile in applicazioni a lunga esecuzione o in processi ad alta intensità di memoria, in cui l'uso della memoria va gestito con maggiore attenzione.

Per attivare manualmente la garbage collection in Python, puoi usare la funzione gc.collect(). Questa funzione forza l'esecuzione immediata del garbage collector, recuperando memoria non più in uso. Ecco come funziona:

import gc
# Trigger garbage collection manually
gc.collect()Offerto da

Quando chiami gc.collect(), il garbage collector di Python esegue una raccolta completa, esaminando tutti gli oggetti in memoria e deallocando quelli che non sono più referenziati. Questo può essere particolarmente utile in scenari come:

• Applicazioni ad alta intensità di memoria: nelle applicazioni che elaborano grandi quantità di dati o creano molti oggetti, attivare manualmente la garbage collection può aiutare a liberare memoria in momenti critici, riducendo il rischio di gonfiore della memoria.
• Processi a lunga esecuzione: in servizi o applicazioni che girano per lunghi periodi, come server o task in background, la gestione manuale può aiutare a mantenere un'impronta di memoria costante, assicurando che l'app rimanga reattiva ed efficiente nel tempo.

Tuttavia, è importante usare gc.collect() con giudizio. Un uso frequente può introdurre overhead non necessario, dato che il processo può essere oneroso in termini di risorse. In genere è meglio usarlo in scenari specifici in cui hai individuato potenziali problemi di memoria o hai bisogno di liberarla in un momento preciso.

Disabilitare la garbage collection

In alcuni casi, può essere utile disabilitare temporaneamente la garbage collection automatica di Python. Questo è utile quando l'overhead della garbage collection potrebbe influire negativamente sulle prestazioni, ad esempio in applicazioni real-time, in sezioni di codice critiche per le performance o durante operazioni in cui vuoi ridurre al minimo le interruzioni.

Per disabilitare il garbage collector, puoi usare la funzione gc.disable():

import gc
# Disable automatic garbage collection
gc.disable()Offerto da

Quando la garbage collection è disabilitata, Python smette di raccogliere e deallocare automaticamente gli oggetti inutilizzati. Questo può portare a prestazioni più prevedibili in alcune situazioni, evitando che il garbage collector si attivi inaspettatamente durante operazioni critiche.

Tuttavia, disabilitare la garbage collection comporta dei rischi:

• Memory leak: senza garbage collection, gli oggetti inutilizzati restano in memoria fino al termine del processo, con il rischio di memory leak. Questo è particolarmente problematico nelle applicazioni a lunga esecuzione, dove l'uso della memoria può crescere senza controllo.
• Riferimenti ciclici: poiché i riferimenti ciclici non vengono risolti automaticamente senza garbage collection, disabilitare il collector può aggravare i problemi di memoria se nel codice sono presenti cicli.

Per questi motivi, è essenziale riabilitare la garbage collection dopo aver eseguito la sezione critica del tuo codice. Puoi riabilitare il collector con gc.enable():

# Re-enable automatic garbage collection
gc.enable()Offerto da

Ecco alcune best practice per la garbage collection manuale:

• Usala con parsimonia: la garbage collection manuale andrebbe applicata solo quando necessario. Un uso eccessivo può peggiorare le prestazioni.
• Combinala con il profiling: prima di attivare manualmente o disabilitare la garbage collection, valuta di profilare l'applicazione per capire i pattern di utilizzo della memoria. Questo ti aiuta a determinare se e dove l'intervento manuale avrà il maggior impatto.
• Riabilitala quando serve: se disabiliti la garbage collection, ricordati di riabilitarla non appena la sezione critica del codice è completata. In questo modo la memoria viene gestita in modo efficiente nel lungo periodo.

Capendo come e quando usare la garbage collection manuale, puoi ottenere un controllo più fine sulla gestione della memoria della tua applicazione. Questo non solo ottimizza le prestazioni, ma previene anche problemi legati alla memoria che potrebbero comprometterne la stabilità.

Nella prossima sezione esploreremo i problemi comuni di garbage collection in Python e forniremo suggerimenti pratici per il debug e la loro risoluzione.

Considerazioni pratiche per gli sviluppatori Python

Gestire la memoria in modo efficiente è fondamentale per scrivere applicazioni Python performanti. Sebbene il sistema di garbage collection di Python gestisca automaticamente la maggior parte dei compiti, ci sono accorgimenti pratici che gli sviluppatori possono adottare per evitare insidie comuni e ottimizzare l'uso della memoria. In questa sezione, esploreremo strategie per evitare i memory leak, gestire i riferimenti ciclici e trattare grandi quantità di oggetti nelle applicazioni Python.

Evitare i memory leak

I memory leak si verificano quando oggetti non più necessari non vengono deallocati correttamente, facendo crescere il consumo di memoria nel tempo. Questo può degradare le prestazioni o addirittura causare il crash dell'applicazione. Per monitorare gli oggetti in memoria, puoi usare il modulo gc di Python. Osservando il numero di oggetti in memoria, puoi rilevare aumenti inattesi che potrebbero indicare un memory leak:

import gc

# Get a list of all objects tracked by the garbage collector
all_objects = gc.get_objects()

print(f"Number of tracked objects: {len(all_objects)}")Offerto da

Se sospetti che un oggetto non venga raccolto, la funzione gc.get_referrers() aiuta a identificare cosa lo mantiene in memoria. Questa funzione restituisce un elenco di oggetti che referenziano quello dato, permettendoti di capire se tali riferimenti sono necessari o possono essere rimossi:

some_object = ...
referrers = gc.get_referrers(some_object)

print(f"Object is being referenced by: {referrers}")Offerto da

Un altro approccio per evitare i memory leak consiste nell'uso di weak reference, soprattutto negli scenari di caching. Il modulo weakref consente di creare riferimenti che non incrementano il contatore di riferimenti dell'oggetto:

import weakref

class MyClass:
    pass
obj = MyClass()
weak_obj = weakref.ref(obj)

print(weak_obj())  # Access the object

del obj  # Delete the strong reference
print(weak_obj())  # None, as the object is now collectedOfferto da

Gestire i riferimenti ciclici

I riferimenti ciclici si verificano quando due o più oggetti si referenziano a vicenda, creando un loop che impedisce ai loro contatori di arrivare a zero. Questo può portare a memory leak se il garbage collector non riesce a rilevarli e raccoglierli.

Il garbage collector generazionale di Python è progettato per gestire i riferimenti ciclici, ma è comunque meglio evitare di crearne di superflui. Usando il modulo gc, puoi rilevare oggetti parte di cicli attivando una raccolta e controllando la lista gc.garbage, che contiene gli oggetti coinvolti in cicli e che non è stato possibile raccogliere:

import gc

# Trigger garbage collection and get the number of uncollectable objects
gc.collect()

uncollectable_objects = gc.garbage
print(f"Number of uncollectable objects: {len(uncollectable_objects)}")Offerto da

Per prevenire i riferimenti ciclici, valuta di spezzare il ciclo rimuovendo esplicitamente i riferimenti quando non servono più. Puoi farlo impostando il riferimento a None o usando weak reference, particolarmente utili per evitare cicli di riferimenti forti. Inoltre, semplificare il design delle tue strutture dati e delle relazioni tra oggetti può ridurre le probabilità di creare cicli.

Gestire un gran numero di oggetti

Creare e distruggere grandi quantità di oggetti in poco tempo può mettere sotto stress il garbage collector di Python. Pensa ad applicazioni che gestiscono grandi dataset, elaborano dati in tempo reale o eseguono operazioni complesse.

Un'idea è batchare la creazione e l'eliminazione degli oggetti. Invece di crearli e distruggerli uno alla volta, raggruppare queste operazioni può ridurre la frequenza della garbage collection e permettere al collector di lavorare in modo più efficiente. Ad esempio:

objects = []

for i in range(1000):
    obj = SomeClass()
    objects.append(obj)

# Process all objects at once, then delete them
del objects[:]
gc.collect()  # Optionally trigger a manual garbage collectionOfferto da

Un'altra considerazione è ottimizzare la durata degli oggetti, assicurandoti che siano o di breve durata o di lunga durata. Gli oggetti di breve durata vengono raccolti rapidamente, mentre quelli di lunga durata vengono spostati nelle generazioni più alte, dove sono raccolti meno frequentemente.

Per scenari in cui gli oggetti vengono creati e distrutti frequentemente, un object pool può essere una tecnica utile. Un object pool riutilizza un numero fisso di oggetti, riducendo il carico sul garbage collector e migliorando le prestazioni in ambienti con memoria limitata. Ecco un esempio di implementazione di un object pool:

class ObjectPool:
    def __init__(self, size):
        self.pool = [SomeClass() for _ in range(size)]
    def get(self):
        return self.pool.pop()
    def release(self, obj):
        self.pool.append(obj)Offerto da

Gli object pool sono particolarmente utili in applicazioni real-time o nei videogiochi, dove le prestazioni sono critiche e l'overhead della creazione e distruzione frequente di oggetti può essere significativo.

Conclusione

In questo articolo abbiamo esplorato il sistema di garbage collection di Python, da come gestisce automaticamente la memoria agli interventi manuali che puoi adottare per migliorarne le prestazioni. La combinazione di reference counting e garbage collection generazionale permette a Python di gestire la memoria in modo efficace, anche se ci sono momenti in cui l'intervento manuale è utile. Seguendo le best practice illustrate, puoi evitare i memory leak, migliorare le prestazioni e avere un maggiore controllo su come le tue applicazioni gestiscono la memoria.

Se vuoi approfondire argomenti avanzati sulla gestione della memoria e sull'ottimizzazione del codice, sono disponibili diverse risorse DataCamp. Puoi leggere i nostri tutorial How to Write Memory-Efficient Classes in Python e Memory Profiling in Python, entrambi utili per individuare i colli di bottiglia. Inoltre, imparare a scrivere codice Python più efficiente è sempre utile per qualsiasi carriera.