Paprèn pira-pira Python ngatur memori lan pengumpulan sampah?

Question

Accepted Answer

Python ngatur memori **kanthi otomatis** nggunakaken rong mekanisme: **reference counting** (cara utama) plus **cyclic garbage collector** sing nangani siklus referensi. Sampeyan ora kudu ngomongake memori kanthi manual, nanging ngerti carane bisa nerangake tingkah laku memori lan bocor.

## Reference counting — mekanisme utama

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

Saben obyek nglacak pinten referensi sing nunjuk marang dheweke. Nalika cacahan mudhun menyang **nol**, memori dibebasake **langsung**. Iki determinisitik lan cepet — obyek mati nalika ora ana sing referensi.

## Masalah: siklus referensi

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

Rong obyek sing referensi saben liyane tetep cacahan referensi siji liyane ing ndhuwur nol sanajan ora bisa dijangkau — siklus sing reference counting murni ora bisa ngumpulake.

## Pengumpul sampah siklus

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

**Generational garbage collector** tambahan Python ndeteksi lan nbebasake siklus ora bisa dijangkau kanthi berkala. Iku *generational* — obyek anyar dicek luwih asring (akeh obyek mati enom), sing éfisien.

## Implikasi praktis & sumber bocor

```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 nangani siklus, nanging ora bisa nbebasake obyek sing isih *bisa dijangkau* — "bocor" real-world umum yaiku nglakoni referensi kanthi ora niat (misale cache global sing tansaya gedhé).

## Rincian liyane

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

## Apa sing penting

Ngerti model memori Python — reference counting cepet plus cyclic GC — nerangake tingkah laku nyata: apa obyek asring dibebasake langsung, apa siklus referensi butuh GC, lan krusial apa "bocor memori" ing Python mula saka referensi *bisa dijangkau* (cache tumuwuh, closure sing linglong, callback sing ora disingkat) tinimbang free sing kalalen.

Ongkol iki penting kanggo diagnosa pertumbuhan memori ing layanan sing tahan lama lan kanggo nulis kode sing migatoken memori — ngerti yen prapen asring bubar referensi (cache sing dibatasi, ngresiki pendaftaran) tinimbang apa-apa sing GC bisa gawe kanggo sampeyan.