Wie verwaltet Python Speicher und Garbage Collection?

Question

Accepted Answer

Python verwaltet Speicher **automatisch** mit zwei Mechanismen: **Referenzzählung** (die primäre Methode) plus einem **zyklischen Garbage Collector**, der Referenzzyklen verarbeitet. Sie müssen nie manuell Speicher freigeben, aber das Verständnis der Funktionsweise erklärt das Speicherverhalten und Speicherlecks.

## Referenzzählung — der primäre Mechanismus

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

Jedes Objekt verfolgt, wie viele Referenzen auf es zeigen. Wenn die Anzahl auf **null** fällt, wird der Speicher **sofort** freigegeben. Dies ist deterministisch und unmittelbar — Objekte werden gelöscht, sobald nichts mehr auf sie verweist.

## Das Problem: Referenzzyklen

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

Zwei Objekte, die aufeinander verweisen, halten gegenseitig ihre Referenzzählerwerte über null, auch wenn sie nicht erreichbar sind — ein Zyklus, den reine Referenzzählung nicht erfassen kann.

## Der zyklische Garbage Collector

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

Pythons ergänzender **generationaler Garbage Collector** erkennt und gibt diese nicht erreichbaren Zyklen periodisch frei. Er ist *generational* — neuere Objekte werden häufiger überprüft (die meisten Objekte haben eine kurze Lebensdauer), was effizient ist.

## Praktische Auswirkungen und Speicherleck-Quellen

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

Der GC verarbeitet Zyklen, kann aber Objekte, die noch *erreichbar* sind, nicht freigeben — das häufige praktische "Speicherleck" ist das unbeabsichtigte Halten von Referenzen (z. B. ein kontinuierlich wachsender globaler Cache).

## Weitere Details

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

## Warum es wichtig ist

Das Verständnis von Pythons Speichermodell — sofortige Referenzzählung plus einem zyklischen GC — erklärt reale Verhaltensweisen: warum Objekte normalerweise sofort freigegeben werden, warum Referenzzyklen den GC benötigen, und entscheidend, warum "Speicherlecks" in Python aus *erreichbaren* Referenzen entstehen (wachsende Caches, persistierende Closures, nicht entfernte Callbacks) statt aus vergessenen Freigaben.

Dieses Wissen ist unverzichtbar für die Diagnose von Speicherwachstum in Langzeitdiensten und zum Schreiben von speichereffizientem Code — mit dem Verständnis, dass die Lösung normalerweise darin besteht, Referenzen zu unterbrechen (Caches zu begrenzen, Registrierungen zu bereinigen) statt dass der GC etwas für Sie tun könnte.