Hvordan håndterer Python minne og søppelinnsamling?

Question

Accepted Answer

Python håndterer minne **automatisk** ved hjelp av to mekanismer: **referansetelling** (den primære metoden) pluss en **syklisk søppelsamler** som håndterer referansesykler. Du trenger aldri å frigjøre minne manuelt, men å forstå hvordan det fungerer forklarer minneatferd og lekkasjer.

## Referansetelling — den primære mekanismen

```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 referanser som peker på det. Når tellingen faller til **null**, frigjøres minnet **umiddelbart**. Dette er deterministisk og raskt — objekter blir fjernet så snart ingenting refererer til dem.

## Problemet: referansesykler

```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 som refererer til hverandre holder hverandres referansetelling over null selv når de er utenfor rekkevidde — en syklus som ren referansetelling ikke kan innsamle.

## Den sykliske søppelsamleren

```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 tilleggsmessige **generasjonell søppelsamler** oppdager og frigjør periodisk disse uoversiktlige syklene. Det er *generasjonelt* — nyere objekter sjekkes oftere (de fleste objekter dør unge), som er effektivt.

## Praktiske implikasjoner og lekkasjekilder

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

Søppelsamleren håndterer sykler, men kan ikke frigjøre objekter som fortsatt er *tilgjengelige* — den vanlige virkelige "lekkasjen" er at du utilsiktet holder referanser levende (f.eks. en stadig 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 betyr noe

Å forstå Pythons minnemodell — rask referansetelling pluss en syklisk GC — forklarer faktisk atferd: hvorfor objekter vanligvis frigjøres umiddelbart, hvorfor referansesykler trenger GC, og avgjørende at "minnelekkasjer" i Python kommer fra *tilgjengelige* referanser (voksende cacher, vedvarende closures, ufjernede callbacks) i stedet for glemte frigjøringer.

Denne kunnskapen er essentiell for å diagnostisere minnevekst i langvarige tjenester og for å skrive minnebevisst kode — å vite at løsningen vanligvis er å bryte referanser (begrense cacher, rydde opp i registreringer) i stedet for noe som helst søppelsamleren kan gjøre for deg.