Conas a bhainistithe Python an cuimhne agus an bhailiúchán dramhaola?

Question

Accepted Answer

Bainistíonn Python an cuimhne **go foluain** ag baint úsáide as dhá dhianmheicníc: **reference counting** (an príomhbhealach) agus **cyclic garbage collector** a dhéileálann le timthriall tagartha. Ní raibh ort cuimhne a scaoileadh go láimhe riamh, ach míníonn tuiscint ar conas a oibríonn sé an iompar cuimhne agus dola.

## Reference counting — an príomhbhealach

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

Tracann gach réad cé mhéad tagairt atá dírithe air. Nuair a thitim an comhaireamh go **nialas**, scaoiltear an cuimhne **láithreach**. Tá sé seo cinnte agus tapa — bíonn bás ar na réada a bheir go bhfuil glan tada ag tagarradh dóibh.

## An fhadhb: timthriall tagartha

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

Coinnítear dhá réad ag tagarradh a chéile ina bhreathnacha ag breacadh os cionn nialas fiú nuair atá siad inábaigthe — timthriall nach féidir le reference counting geal a bhailíonn.

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

Déanann **generational garbage collector** bhreise Python timthrialla nach inrochtana a aimsiú agus a scaoileadh go tréimhsiúil. Tá sé *generational* — déantar iniúchadh ar réada níos nuaí níos minic (faillíonn an chuid is mó de na réada go luath), atá éifeachtach.

## Impleoidí praiticiúla & foinse dola

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

Déanann an GC déileáil le timthrialla, ach ní féidir léi réada a scaoileadh atá fós *inrochtana* — an "dola" coitianta i saol an tsaoil ná tagartha a choimeád beo go neamhbheartaithe (mar shampla, taisce dhomhanda a fhásann i gcónaí).

## Sonraí eile

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

## Cén fáth a bhfuil sé tábhachtach

Míníonn tuiscint ar mhúnla cuimhne Python — reference counting tapa agus cyclic GC — iompar fíor: cén fáth a scaoiltear réada de ghnáth láithreach, cén fáth a bhfuil gá ag timthrialla tagartha do an GC, agus go criticiúil cén fáth a thagann "dola cuimhne" i Python ó *inrochtana* tagartha (taiscí a fhásann, dúnadh fada, callbacks nach bhfuaireadh a bhaint) seachas frees déanta dearmad.

Tá an eolas seo riachtanach chun fás cuimhne a dhiagnóistiú i seirbhísí fada-reata agus chun cód a scríobh a bheidh feasach ar chuimhne — a bheith ar eolas gur é an leigheas ná tagartha a bhriseadh (taiscí a bhunú, glanadh a dhéanamh ar chlárúcháin) seachal rud ar bith ar féidir leis an GC a dhéanamh duit.