Python میموری اور garbage collection کو کیسے سنبھالتا ہے؟

Question

Accepted Answer

Python میموری کو **خودکار** طور پر دو طریقہ کاروں سے سنبھالتا ہے: **reference counting** (بنیادی طریقہ) نیز ایک **cyclic garbage collector** جو reference cycles کو سنبھالتا ہے۔ آپ کبھی manually میموری free نہیں کرتے، لیکن یہ سمجھنا کہ یہ کیسے کام کرتا ہے میموری کے رویے اور leaks کی وضاحت کرتا ہے۔

## Reference counting — بنیادی طریقہ کار

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

ہر object یہ ٹریک کرتا ہے کہ کتنے references اس کی طرف اشارہ کرتے ہیں۔ جب count **صفر** تک گر جاتا ہے، تو میموری **فوراً** free کر دی جاتی ہے۔ یہ deterministic اور فوری ہے — objects اسی وقت ختم ہو جاتے ہیں جب کوئی چیز ان کا reference نہیں رکھتی۔

## مسئلہ: reference cycles

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

ایک دوسرے کا reference رکھنے والے دو objects unreachable ہونے کے باوجود ایک دوسرے کے refcount کو صفر سے اوپر رکھتے ہیں — ایک cycle جسے خالص reference counting collect نہیں کر سکتی۔

## 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 کا تکمیلی **generational garbage collector** وقتاً فوقتاً ان unreachable cycles کا پتہ لگاتا اور انہیں free کرتا ہے۔ یہ *generational* ہے — نئے objects کو زیادہ کثرت سے چیک کیا جاتا ہے (زیادہ تر objects جلد ختم ہو جاتے ہیں)، جو efficient ہے۔

## عملی مضمرات اور leak کے ماخذ

```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 cycles کو سنبھالتا ہے، لیکن یہ ان objects کو free نہیں کر سکتا جو ابھی بھی *reachable* ہیں — عام حقیقی دنیا کا "leak" غیر ارادی طور پر references کو زندہ رکھنا ہے (مثلاً ایک مسلسل بڑھتا ہوا global cache)۔

## دیگر تفصیلات

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

## یہ کیوں اہم ہے

Python کے memory model کو سمجھنا — فوری reference counting نیز ایک cyclic GC — حقیقی رویوں کی وضاحت کرتا ہے: objects عام طور پر فوراً free کیوں ہوتے ہیں، reference cycles کو GC کی ضرورت کیوں ہے، اور سب سے اہم یہ کہ Python میں "memory leaks" بھولے ہوئے frees کے بجائے *reachable* references (بڑھتے ہوئے caches، باقی رہنے والے closures، نہ ہٹائے گئے callbacks) سے کیوں آتے ہیں۔

یہ علم long-running services میں میموری کی نمو کی تشخیص اور میموری سے باخبر code لکھنے کے لیے ضروری ہے — یہ جاننا کہ حل عموماً references توڑنا ہے (caches کو محدود کرنا، registrations کی صفائی) نہ کہ کوئی ایسی چیز جو GC آپ کے لیے کر سکے۔