Python मेमरी आणि गार्बेज कलेक्शन कसे व्यवस्थापित करते?

Question

IT Interview Practice · Accepted Answer

Python मेमरी **स्वयंचलितपणे** दोन यंत्रणा वापरून व्यवस्थापित करते: **संदर्भ गणना** (प्राथमिक पद्धति) तसेच एक **चक्रीय गार्बेज कलेक्टर** जो संदर्भ चक्र हाताळते. आपण कधीही मेमरी मुक्त करत नाही, परंतु हे कसे काम करते हे समजून घेतल्याने मेमरी वर्तन आणि लीक समजण्यास मदत मिलते.

## संदर्भ गणना — प्राथमिक यंत्रणा

```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 आपल्यासाठी काही करू शकते.

संदर्भ गणना — प्राथमिक यंत्रणा

समस्या: संदर्भ चक्र

चक्रीय गार्बेज कलेक्टर

व्यावहारिक परिणाम आणि लीक स्रोत

इतर तपशील

हे का महत्त्वाचे आहे

संबंधित प्रश्न