Python మెమరీని ఎలా నిర్వహిస్తుంది మరియు చెత్త సేకరణ ఎలా చేస్తుంది?

Question

Accepted Answer

Python మెమరీని **స్వయంచాలకంగా** రెండు విధానాలను ఉపయోగించి నిర్వహిస్తుంది: **సూచన గణన** (ప్రాథమిక పద్ధతి) ప్లస్ **చక్రీయ చెత్త సేకరకుడు** ఇది సూచన చక్రాలను నిర్వహిస్తుంది. మీరు ఎప్పుడూ మెమరీని స్వmanually విడుదల చేయవలసిన లేదు, కానీ ఇది ఎలా పనిచేస్తుందో అర్థం చేసుకోవడం మెమరీ ప్రవర్తన మరియు లీకులను వివరిస్తుంది.

## సూచన గణన — ప్రాథమిక విధానం

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

ప్రతిটి వస్తువు దానిపై ఎన్ని సూచనలు చూపుతున్నాయో ట్రాక్ చేస్తుంది. గణన **సున్నాకు** క్షీణించినప్పుడు, మెమరీ **తక్షణమే** విడుదల చేయబడుతుంది. ఇది నిర్ణయాత్మకమైనది మరియు ఎటువంటి సూచన లేనిసరిగానే వస్తువులు అంతరించిపోతాయి.

## సమస్య: సూచన చక్రాలు

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

రెండు వస్తువులు ఒకదానిని రెండవది సూచిస్తే ఒకదానిని మరొకటి సూచిస్తూ ఉంటుంది వాటి refcount సున్నా కంటే ఎక్కువ ఉంటుంది అయినప్పటికీ చేరుకోలేనిది — ఒక చక్రం ఇది స్వచ్ఛ సూచన గణన సేకరించలేదు.

## చక్రీయ చెత్త సేకరకుడు

```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 యొక్క అనుబంధ **జనరేషనల్ చెత్త సేకరకుడు** ఆవర్తనకాలికంగా ఈ చేరుకోలేని చక్రాలను గుర్తించి విడుదల చేస్తుంది. ఇది *జనరేషనల్* — కొత్త వస్తువులు చాలా తరచుగా తనిఖీ చేయబడతాయి (చాలా వస్తువులు చిన్నపుడే చనిపోతాయి), ఇది సమర్థవంతమైనది.

## ఆచరణాత్మక చిక్కులు & లీక్ మూలాలు

```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 చక్రాలను నిర్వహిస్తుంది, కానీ ఇది ఇప్పటికీ *చేరుకోలేని* వస్తువులను విడుదల చేయలేదు — సాధారణ వాస్తవ-ప్రపంచ "లీక్" ఉద్దేశ్యపూర్వకంగా సూచనలను జీవంగా ఉంచడం (ఉదా అంతులేని ప్రపంచ క్యాష్).

## ఇతర వివరాలు

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

## దీని ప్రాముఖ్యత

Python యొక్క మెమరీ నమూనాను అర్థం చేసుకోవడం — తక్షణ సూచన గణన ప్లస్ చక్రీయ GC — నిజమైన ప్రవర్తనలను వివరిస్తుంది: సూచనలు సాధారణంగా తక్షణమే ఎందుకు విడుదల చేయబడతాయి, సూచన చక్రాలకు GC ఎందుకు అవసరమైనవి, మరియు ముఖ్యంగా Python లో "మెమరీ లీక్‌లు" *చేరుకోలేని* సూచనల నుండి వస్తాయి (సూచనలను విడిచిపెట్టడం, క్లోజర్‌లను నిర్మూలించడం, కాల్‌బ్యాక్‌లను తీసివేయడం) కాకుండా మరిన్ని విస్మరించిన విడుదలల కంటే.

ఈ జ్ఞానం దీర్ఘకాల సేవలలో మెమరీ వృద్ధిని నిర్ధారణ చేయడానికి మరియు మెమరీ-సচేతమైన కోడ్ రాయడానికి ఇది అవసరం — సూచనలను విభజించడం (క్యాష్‌లను సరిహద్దు చేయడం, నিబంధనలను శుభ్రపరచడం) దానిపై GC చేయగలిన ఏదైనా కంటే సమాధానం సాధారణంగా ఉంటుందని తెలుసుకోవడం.