Kako Python upravlja memorijom i prikupljanjem otpada?

Question

Accepted Answer

Python upravlja memorijom **automatski** koristeći dva mehanizma: **reference counting** (primarni način) i **cyclic garbage collector** koji rukuje ciklusa referenci. Nikad ne trebate ručno osloboditi memoriju, ali razumijevanje kako to funkcionira objašnjava ponašanje memorije i curenja.

## Reference counting — primarni mehanizam

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

Svaki objekt prati koliko referenci pokazuje na njega. Kada se broj spusti na **nulu**, memorija se oslobađa **odmah**. Ovo je determinističko i brzo — objekti umiru čim ništa ne pokazuje na njih.

## Problem: ciklusi referenci

```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 objekta koja međusobno referenciraju drže refcount jednog drugoga iznad nule čak i kada su nedostižni — ciklus koji čisto reference counting ne može prikupiti.

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

Python-ov dodatni **generacijski garbage collector** periodički detektuje i oslobađa ove nedostižne cikluse. On je *generacijski* — noviji objekti se provjeravaju češće (većina objekata umire rano), što je učinkovito.

## Praktične implikacije i izvori curenja

```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 rukuje ciklusa, ali ne može osloboditi objekte koji su još *dostižni* — česta stvarna "curenja" je nenamjerno čuvanje referenci živima (npr. sve veća globalna cache).

## Ostali detalji

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

## Zašto je važno

Razumijevanje Python-ovog modela memorije — brzo reference counting plus cyclic GC — objašnjava pravo ponašanje: zašto se objekti obično oslobađaju odmah, zašto reference ciklusi trebaju GC, i ključno zašto "curenja memorije" u Python-u dolaze iz *dostižnih* referenci (rastuće cache, otvoreni closures, neuklanjani callbacks) umjesto zaboravljenih oslobađanja.

Ovo znanje je bitno za dijagnozu rasta memorije u dugoročnim servisima i pisanja memory-conscious koda — znati da je ispravka obično prekidanje referenci (ograničavanje cache, čišćenje registracija) umjesto nečega što GC može za vas napraviti.