Kaip Python valdo atmintį ir šiukšlių surinkimą?

Question

Accepted Answer

Python valdo atmintį **automatiškai** naudodamas du mechanizmus: **nuorodų skaičiavimą** (pagrindinį metodą) ir **ciklinį šiukšlių surinkiklį**, kuris tvarko nuorodų ciklus. Jūs niekada neturite rankiniu būdu atlaisvinti atmintį, tačiau supratimas, kaip tai veikia, paaiškina atminties elgesį ir nuotėkius.

## Nuorodų skaičiavimas — pagrindinis mechanizmas

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

Kiekvienas objektas seka, kiek nuorodų į jį rodo. Kai skaičius nukrenta iki **nulio**, atmintis atlaisvinamos **iš karto**. Tai yra deterministiška ir greitai veikianti — objektai gyvena tol, kol yra bent kažkokios nuorodos į juos.

## Problema: nuorodų ciklai

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

Du objektai, vienas į kitą nurodantys, vienas kitą pasaulyje išlaikyda, net kai jie yra nepasiekiami — ciklas, kurį grynasis nuorodų skaičiavimas negali surinkti.

## Ciklinis šiukšlių surinkiklis

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

Python papildantis **generacinis šiukšlių surinkiklis** periodiškai aptinka ir atlaisvina šiuos nepasiekiamus ciklus. Jis yra *generacinis* — naujesni objektai tikrinami dažniau (dauguma objektų gyvena trumpai), kas yra efektyviai.

## Praktinės implikacijos ir nuotėkio šaltiniai

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

Šiukšlių surinkiklis tvarko ciklus, tačiau negali atlaisvinti objektų, kurie vis dar yra *pasiekiami* — tipiška realaus pasaulio "nuotėkis" yra netyčia nuorodas išlaikimu gyvas (pavyzdžiui, nuolat auganti globali talpykla).

## Kitos detalės

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

## Kodėl tai svarbu

Supratimas apie Python atminties modelį — greitą nuorodų skaičiavimą ir ciklinį šiukšlių surinkiklį — paaiškina tikrąjį elgesį: kodėl objektai paprastai atlaisvinami iš karto, kodėl nuorodų ciklai turi šiukšlių surinkiklį, ir žymiai svarbesne, kodėl Python "atminties nuotėkiai" gaunasi iš *pasiekiamų* nuorodų (augančios talpyklos, likusios uždarytos funkcijos, neišimti atgalinio skambučiai) o ne iš pamiršų atlaisvinimo.

Šis žinojimas yra būtinas ilgalaikių paslaugų atminties augimo diagnozavimui ir atminties sąvesto kodo rašymui — žinant, kad sprendimas paprastai yra nuorodų nutraukimas (talpyklų ribojimas, registracijų valymas) o ne anything šiukšlių surinkiklis gali padaryti jūsų vardu.