Jak Python spravuje paměť a garbage collection?

Question

Accepted Answer

Python spravuje paměť **automaticky** pomocí dvou mechanismů: **reference counting** (primární metoda) plus **cyklický garbage collector**, který zpracovává cyklické reference. Nikdy ručně neuvolňujete paměť, ale pochopení toho, jak to funguje, vysvětluje chování paměti a možné úniky.

## Reference counting — primární 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
```

Každý objekt sleduje, kolik referencí na něj ukazuje. Když počet klesne na **nulu**, paměť je uvolněna **okamžitě**. Toto je deterministické a rychlé — objekty zanikají hned, když se na ně nic neodkazuje.

## Problém: cyklické reference

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

Dva objekty odkazující na sebe navzájem si udržují počty referencí výše než nula, i když jsou nedosažitelné — cyklus, který čistý reference counting nemůže sebrat.

## Cyklický 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
```

Doplňkový **generační garbage collector** Pythonu periodicky detekuje a uvolňuje tyto nedosažitelné cykly. Je *generační* — novější objekty jsou kontrolovány oftěji (většina objektů žije krátce), což je efektivní.

## Praktické důsledky a zdroje úniků

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

GC zpracovává cykly, ale nemůže uvolnit objekty, které jsou stále *dosažitelné* — běžný reálný "únik" je neúmyslné udržování referencí na živu (např. neustále rostoucí globální cache).

## Další detaily

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

## Proč to má smysl

Pochopení Pythonova paměťového modelu — okamžitý reference counting plus cyklický GC — vysvětluje skutečné chování: proč jsou objekty obvykle uvolněny okamžitě, proč cyklické reference potřebují GC, a zejména proč "úniky paměti" v Pythonu pocházejí z *dosažitelných* referencí (rostoucí caches, trvalé closures, neodstraněné callbacks) spíše než z zapomenutých uvolnění.

Toto poznání je nezbytné pro diagnostiku nárůstu paměti v dlouhotrvajících službách a pro psaní paměťově vědomého kódu — vědět, že řešením je obvykle přerušení referencí (omezení caches, čištění registrací) spíše než něco, co by pro vás mohl udělat GC.