Bagaimana Python mengelola memori dan pengumpulan sampah?

Question

Accepted Answer

Python mengelola memori **secara otomatis** menggunakan dua mekanisme: **reference counting** (metode utama) dan **cyclic garbage collector** yang menangani siklus referensi. Anda tidak perlu membebaskan memori secara manual, tetapi memahami cara kerjanya menjelaskan perilaku memori dan kebocoran.

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

Setiap objek melacak berapa banyak referensi yang menunjuk padanya. Ketika penghitungan turun ke **nol**, memori dibebaskan **segera**. Ini bersifat deterministik dan cepat — objek mati segera setelah tidak ada yang mereferensikannya.

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

Dua objek yang saling mereferensikan membuat refcount satu sama lain tetap di atas nol bahkan ketika tidak dapat dijangkau — siklus yang tidak dapat dikumpulkan oleh reference counting murni.

## Pengumpul sampah siklik

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

Pengumpul sampah **generasi** tambahan Python secara berkala mendeteksi dan membebaskan siklus yang tidak dapat dijangkau ini. Ini adalah *generasi* — objek yang lebih baru diperiksa lebih sering (sebagian besar objek mati muda), yang efisien.

## Implikasi praktis & sumber kebocoran

```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 menangani siklus, tetapi tidak dapat membebaskan objek yang masih *dapat dijangkau* — "kebocoran" dunia nyata yang umum adalah secara tidak sengaja menjaga referensi tetap hidup (misalnya, cache global yang terus bertambah).

## Detail lainnya

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

## Mengapa ini penting

Memahami model memori Python — reference counting cepat ditambah cyclic GC — menjelaskan perilaku nyata: mengapa objek biasanya dibebaskan segera, mengapa siklus referensi memerlukan GC, dan yang paling penting mengapa "kebocoran memori" dalam Python berasal dari referensi *dapat dijangkau* (cache yang bertambah, closure yang tertunda, callback yang tidak dihapus) daripada pembebasan yang terlupakan.

Pengetahuan ini sangat penting untuk mendiagnosis pertumbuhan memori di layanan jangka panjang dan menulis kode yang sadar memori — mengetahui bahwa perbaikannya biasanya memutus referensi (membatasi cache, membersihkan pendaftaran) daripada apa pun yang dapat dilakukan GC untuk Anda.