Bagaimana Python menguruskan memori dan kutipan sampah (garbage collection)?

Question

IT Interview Practice · Accepted Answer

Python menguruskan memori **secara automatik** menggunakan dua mekanisme: **pengiraan rujukan (reference counting)** (kaedah utama) ditambah pula dengan **pengutip sampah berkitar (cyclic garbage collector)** yang mengendalikan kitaran rujukan. Anda tidak pernah membebaskan memori secara manual, tetapi memahami cara ia berfungsi akan menjelaskan tingkah laku memori dan kebocoran.

## Pengiraan rujukan — 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 menjejaki bilangan rujukan yang menunjuk kepadanya. Apabila kiraan jatuh ke **sifar**, memori dibebaskan **serta-merta**. Ini bersifat deterministik dan segera — objek mati sebaik sahaja tiada apa-apa yang merujuknya.

## Masalahnya: kitaran rujukan

```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 merujuk antara satu sama lain mengekalkan kiraan rujukan masing-masing melebihi sifar walaupun tidak boleh dicapai — satu kitaran yang tidak dapat dikutip oleh pengiraan rujukan semata-mata.

## Pengutip sampah berkitar

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

**Pengutip sampah bergenerasi** tambahan Python secara berkala mengesan dan membebaskan kitaran yang tidak boleh dicapai ini. Ia bersifat *bergenerasi* — objek yang lebih baharu diperiksa lebih kerap (kebanyakan objek mati muda), yang mana ia cekap.

## Implikasi praktikal & punca 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 mengendalikan kitaran, tetapi ia tidak boleh membebaskan objek yang masih *boleh dicapai* — "kebocoran" dunia sebenar yang biasa ialah mengekalkan rujukan hidup secara tidak sengaja (cth. cache global yang sentiasa membesar).

## Butiran lain

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

## Mengapa ia penting

Memahami model memori Python — pengiraan rujukan yang segera ditambah GC berkitar — menjelaskan tingkah laku sebenar: mengapa objek biasanya dibebaskan serta-merta, mengapa kitaran rujukan memerlukan GC, dan yang penting mengapa "kebocoran memori" dalam Python datang daripada rujukan yang *boleh dicapai* (cache yang membesar, closure yang berlegar, callback yang tidak dibuang) dan bukannya pembebasan yang terlupa.

Pengetahuan ini penting untuk mendiagnosis pertumbuhan memori dalam perkhidmatan yang berjalan lama dan untuk menulis kod yang prihatin-memori — mengetahui bahawa penyelesaiannya biasanya memutuskan rujukan (membataskan cache, membersihkan pendaftaran) dan bukannya apa-apa yang GC boleh lakukan untuk anda.

Pengiraan rujukan — mekanisme utama

Masalahnya: kitaran rujukan

Pengutip sampah berkitar

Implikasi praktikal & punca kebocoran

Butiran lain

Mengapa ia penting

Soalan berkaitan