Hogyan kezeli a Python a memóriát és a szemét gyűjtést?

Question

Accepted Answer

A Python **automatikusan** kezeli a memóriát két mechanizmus segítségével: **reference counting** (az elsődleges módszer) és egy **ciklikus szemétgyűjtő**, amely a referencia-ciklusa okat kezeli. Soha nem kell manuálisan felszabadítania a memóriát, de annak megértése, hogyan működik, megmagyarázza a memória viselkedését és a szivárgásokat.

## Reference counting — az elsődleges mechanizmus

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

Minden objektum nyomon követi, hogy hány referencia mutat rá. Amikor a szám **nullára** csökken, a memória **azonnal** felszabadul. Ez determinisztikus és gyors — az objektumok azonnal meghalnak, ha semmi sem hivatkozik rájuk.

## A probléma: referencia-ciklusa ok

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

Két objektum, amely egymásra hivatkozik, egymás refcount-ját a nulla fölött tartja, még akkor is, ha elérhetetlen — egy olyan ciklus, amelyet a tiszta referencia-számlálás nem tud begyűjteni.

## Ciklikus szemétgyűjtő

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

A Python kiegészítő **generációs szemétgyűjtője** periodikusan észleli és felszabadítja ezeket az elérhetetlen ciklus okat. *Generációs* — az újabb objektumok gyakrabban ellenőrizhetők (a legtöbb objektum fiatalon hal meg), amely hatékony.

## Gyakorlati következmények és szivárgásforrások

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

A GC kezeli a ciklusa okat, de nem tudja felszabadítani azokat az objektumokat, amelyek még *elérhetők* — az általános valós világbeli "szivárgás" az, hogy szándéktalanul életben tartanak referenciákat (például egy folyamatosan növekvő globális gyorsítótár).

## Egyéb részletek

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

## Miért fontos

A Python memóriamodelljének megértése — gyors referencia-számlálás és ciklikus GC — valós viselkedést magyaráz meg: miért szabadul fel az objektumok általában azonnal, miért kell a referencia-ciklusa oknak a GC-hez, és döntően miért jönnek a Python-beli "memóriaszivárgások" az *elérhető* referenciákból (növekvő gyorsítótárak, függőben lévő bezárások, eltávolított visszahívások), ahelyett, hogy elfeledett felszabadítások lennének.

Ez a tudás elengedhetetlen a memóriavesztés diagnózisához hosszú távú szolgáltatásokban és a memóriara érzékeny kód írásához — tudni, hogy a megoldás általában a referenciák megtörése (gyorsítótárak korlátozása, regisztrációk megtisztítása), nem pedig valami, amit a GC meg tud tenni az Ön számára.