Come Python gestisce la memoria e la raccolta dei rifiuti?

Question

Accepted Answer

Python gestisce la memoria **automaticamente** utilizzando due meccanismi: **reference counting** (il metodo principale) più un **garbage collector ciclico** che gestisce i cicli di riferimento. Non devi mai liberare la memoria manualmente, ma comprendere come funziona spiega il comportamento della memoria e le perdite.

## Reference counting — il meccanismo principale

```python
import sys

x = [1, 2, 3]        # the list object has refcount 1
y = x                 # refcount 2 (another name references it)
sys.getrefcount(x)    # shows the count (slightly higher due to the call itself)

del y                 # refcount 1
del x                 # refcount 0 → the object is FREED immediately
```

Ogni oggetto tiene traccia di quanti riferimenti lo puntano. Quando il conteggio scende a **zero**, la memoria viene liberata **immediatamente**. Questo è deterministico e veloce — gli oggetti muoiono non appena nulla li riferisce.

## Il problema: cicli di riferimento

```python
# reference counting alone can't free this:
a = {}
b = {}
a["b"] = b      # a references b
b["a"] = a      # b references a → they reference EACH OTHER
del a, b        # the names are gone, but the objects still reference each other
# → refcounts never reach 0 → they'd leak with refcounting alone
```

Due oggetti che si riferiscono l'uno all'altro mantengono il refcount dell'altro al di sopra di zero anche quando irraggiungibili — un ciclo che il semplice reference counting non può raccogliere.

## Il garbage collector ciclico

```python
import gc

# the generational GC periodically finds and frees unreachable CYCLES
gc.collect()        # manually trigger a collection
gc.get_count()      # objects tracked per generation
```

Il **garbage collector generazionale** supplementare di Python rileva periodicamente e libera questi cicli irraggiungibili. È *generazionale* — gli oggetti più recenti vengono controllati più spesso (la maggior parte degli oggetti muore giovane), il che è efficiente.

## Implicazioni pratiche & fonti di perdita

```text
✓ Most memory is reclaimed promptly via reference counting
⚠️ Leaks still happen from REACHABLE references that outlive their usefulness:
   - global caches/lists that only grow
   - objects held by long-lived closures or class attributes
   - registered callbacks/listeners never removed
```

Il GC gestisce i cicli, ma non può liberare oggetti ancora *raggiungibili* — la comune "perdita" del mondo reale è mantenere involontariamente i riferimenti in vita (ad esempio, una cache globale sempre crescente).

## Altri dettagli

```text
- Small integers (-5..256) and short strings are CACHED/interned (shared, reused)
- CPython uses memory pools (pymalloc) for small objects (efficiency)
```

## Perché è importante

Comprendere il modello di memoria di Python — reference counting veloce più GC ciclico — spiega i comportamenti reali: perché gli oggetti di solito vengono liberati immediatamente, perché i cicli di riferimento hanno bisogno del GC, e crucialmente perché le "perdite di memoria" in Python provengono da riferimenti *raggiungibili* (cache in crescita, closure persistenti, callback non rimossi) anziché da liberazioni dimenticate.

Questa conoscenza è essenziale per diagnosticare la crescita della memoria nei servizi a lunga durata e per scrivere codice consapevole della memoria — sapere che la soluzione è solitamente interrompere i riferimenti (limitare le cache, ripulire le registrazioni) piuttosto che qualcosa che il GC possa fare per te.