Python memory மற்றும் garbage collection-ஐ எவ்வாறு நிர்வகிக்கிறது?

Question

Accepted Answer

Python memory-ஐ **தானாகவே** இரண்டு வழிமுறைகளைப் பயன்படுத்தி நிர்வகிக்கிறது: **reference counting** (முதன்மை முறை) கூடுதலாக reference cycles-ஐ கையாளும் **cyclic garbage collector**. நீங்கள் ஒருபோதும் memory-ஐ கைமுறையாக விடுவிப்பதில்லை, ஆனால் அது எப்படி வேலை செய்கிறது என்பதைப் புரிந்துகொள்வது memory நடத்தை மற்றும் 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 **பூஜ்ஜியத்திற்கு** குறையும்போது, memory **உடனடியாக** விடுவிக்கப்படுகிறது. இது determined மற்றும் உடனடியானது — எதுவும் reference செய்யாதவுடன் objects இறந்துவிடுகின்றன.

## பிரச்சினை: 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, அணுக முடியாதபோதும் ஒன்றோடொன்றின் refcount-ஐ பூஜ்ஜியத்திற்கு மேல் வைத்திருக்கின்றன — தூய reference counting சேகரிக்க முடியாத ஒரு cycle.

## 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** இந்த அணுக முடியாத cycles-ஐ அவ்வப்போது கண்டறிந்து விடுவிக்கிறது. இது *generational* — புதிய objects அடிக்கடி சரிபார்க்கப்படுகின்றன (பெரும்பாலான objects இளமையில் இறக்கின்றன), இது திறமையானது.

## நடைமுறை விளைவுகள் & 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-ஐ அது விடுவிக்க முடியாது — பொதுவான உண்மை-உலக "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 ஏன் பொதுவாக உடனடியாக விடுவிக்கப்படுகின்றன, reference cycles ஏன் GC தேவை, மற்றும் முக்கியமாக Python-இல் "memory leaks" ஏன் மறந்துபோன frees-ஐ விட *அணுகக்கூடிய* references-இலிருந்து (வளரும் caches, தங்கியிருக்கும் closures, அகற்றப்படாத callbacks) வருகின்றன.

இந்த அறிவு நீண்டகாலம் இயங்கும் services-இல் memory வளர்ச்சியை diagnose செய்வதற்கும், memory-உணர்வுள்ள code எழுதுவதற்கும் இன்றியமையாதது — தீர்வு பொதுவாக GC உங்களுக்காகச் செய்யக்கூடிய எதையும் விட references-ஐ உடைப்பதே (caches-ஐ வரம்புப்படுத்துதல், registrations-ஐ சுத்தம் செய்தல்) என்பதை அறிந்துகொள்வது.