Hvordan håndterer Python hukommelse og garbage collection?

Question

Accepted Answer

Python håndterer hukommelse **automatisk** ved hjælp af to mekanismer: **reference counting** (den primære metode) plus en **cyklisk garbage collector**, der håndterer reference-cyklusser. Du skal aldrig manuelt frigive hukommelse, men at forstå hvordan det virker forklarer hukommelses-adfærd og hukommelsesbortfaldet.

## Reference counting — den primære mekanisme

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

Hvert objekt sporer, hvor mange referencer der peger på det. Når antallet falder til **nul**, frigives hukommelsen **umiddelbart**. Dette er deterministisk og prompte — objekter dør så snart intet henviser til dem.

## Problemet: reference-cyklusser

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

To objekter, der henviser til hinanden, holder hinandens refcount over nul, selv når de er utilgængelige — en cykel, som ren reference counting ikke kan indsamle.

## Den cykliske 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 supplerende **generationel garbage collector** opdager og frigiver periodisk disse utilgængelige cyklusser. Det er *generationelt* — nyere objekter kontrolleres oftere (de fleste objekter dør unge), hvilket er effektivt.

## Praktiske implikationer og hukommelsesbortfalds-kilder

```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 håndterer cyklusser, men kan ikke frigive objekter, der stadig er *tilgængelige* — den almindelige virkelige "hukommelses-bortfald" er utilsigtet at holde referencer levende (f.eks. en stadigt voksende global cache).

## Andre detaljer

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

## Hvorfor det betyder noget

At forstå Pythons hukommelsesmodel — prompte reference counting plus en cyklisk GC — forklarer real adfærd: hvorfor objekter normalt frigives umiddelbart, hvorfor reference-cyklusser har brug for GC, og afgørende hvorfor "hukommelses-bortfald" i Python kommer fra *tilgængelige* referencer (voksende caches, vedvarende closures, fjernede callbacks) i stedet for glemte freeinger.

Denne viden er afgørende for diagnosticering af hukommelses-vækst i længerevarende services og for at skrive hukommelse-bevidst kode — at vide, at løsningen normalt er at bryde referencer (begræns caches, rens registreringer) snarere end noget GC kan gøre for dig.