Paano Python ke sarrafa alaƙa da tahsil ƙumamshi?

Question

Accepted Answer

Python ke sarrafa alaƙa ta **atomatik** ta hanyar amfani da hanyoyi biyu: **reference counting** (hanya na farko) tare da **cyclic garbage collector** wanda ke tunani da zawaye na reference. Ba ka buƙatar ɓata alaƙa ta hannu kaikayi, amma fahimtar yadda take aiki tana bayyana halin alaƙa da hako.

## Reference counting — hanya na farko

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

Kowane abu ke fita yadda yawa references suke nuni wa shi. Lokacin da aka raba don **sifili**, alaƙa ta aka fita **nan take**. Wannan ya kasance sarkakki da hanzari — abubuwan kuma karshe da kaƙaf komi shine nuni su.

## Matsala: zawaye na reference

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

Abubuwa biyu suke nuni a juna suke rike refcount na juna sama da sifili har yanzu lokacin da ba a iya ja — zaway wanda mahaulaye reference counting ba zai iya kolekti.

## 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 supplemental **generational garbage collector** ta yau da kullun gano da fita wa waɗannan abubuwan ba a iya ja su. Yake *generational* — sabubuwa saiwa aka jage sau-sau (yawancin abubuwa suna mutuwa jiya), wanda yakamata.

## Sakamakon faɗi-sama & tushen ƙumamshi

```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 ta taɓa zawaye, amma ba zai iya fita abubuwa da noma *reachable* — gama-gama sashe na tunani "ƙumamshi" yoyo shine ƙaƙƙarfa a hannu taibaye (misali, cache na jiya wanda kike karuwa).

## Sauran bayanan

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

## Me yasa ya kamata

Fahimtar alaƙa-model na Python — ƙunƙura reference counting tare da cyclic GC — tana bayyana ainihi: me yasa abubuwa galibi an fita na nan take, me yasa zawaye na reference suke bukatan GC, da muhimmanci me yasa "alaƙa-ƙumamshi" a cikin Python suke zo daga *reachable* references (karuwar cache, lingering closures, un-removed callbacks) maimakon samantaccen ɓata.

Ilimin da wannan ya zama dole ga gano canji na alaƙa a cikin sabis na dogon lokaci da rubuta code wanda ke tasiri ga alaƙa — san cewa maganin da ke kusan koda shine cire references (iyakance cache, tsaftace nai-nai) maimakon kome GC na iya yi maka.