Si e menaxhon Python-i kujtesën dhe mbledhjen e mbeturinave?

Question

Accepted Answer

Python menaxhon kujtesën **automatikisht** duke përdorur dy mekanizma: **numërimi i referencave** (metoda kryesore) plus një **mbledhës ciklik të mbeturinave** që trajton ciklat e referencave. Nuk duhet të çlirojnë ndonjëherë kujtesën manualisht, por të kuptimit se si funksionon shpjegon sjelljen e kujtesës dhe rrjedhjet.

## Numërimi i referencave — mekanizmi kryesor

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

Çdo objekt ndjek sa referenca tregojnë ndaj tij. Kur numri bie në **zero**, kujtesa çlirohet **menjëherë**. Kjo është përcaktuese dhe e shpejtë — objektet vdesin sapo asgjë nuk i referon ato.

## Problemi: ciklat e referencave

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

Dy objekta që referohen njëri-tjetrit mbajnë refcount të njëri-tjetrit mbi zero edhe kur janë të paarritshme — një cikël që numërimi i pastër i referencave nuk mund ta mbledhë.

## Mbledhësi ciklik i mbeturinave

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

Mbledhësi **gjeneracional i mbeturinave** plotësues i Python-it periodikisht gjen dhe liroi këto cikle të paarritshme. Është *gjeneracional* — objektet më të reja kontrollohen më shpesh (shumica e objekteve vdesin të rinj), që është efikase.

## Implikime praktike & burimet e rrjedhjes

```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 trajton ciklat, por nuk mund të liroj objektet që janë ende *të arritshme* — "rrjedhja" e zakonshme në botën reale është mbajta e padëshirueshme e referencave të gjallë (për shembull një cache globale që rritet përgjithmonë).

## Detaje të tjera

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

## Pse ka rëndësi

Të kuptimi i modelit të kujtesës i Python-it — numërimi i shpejtë i referencave plus një GC ciklik — shpjegon sjellje të vërteta: pse objektet zakonisht çlirohen menjëherë, pse ciklat e referencave kanë nevojë për GC-në, dhe në mënyrë vendimtare pse "rrjedhjet e kujtesës" në Python vijnë nga *referenca të arritshme* (cache në rritje, mbyllje të zgjatura, callback të pa-hequr) dhe jo nga harrimi i çlirimeve.

Kjo njohuri është thelbësore për diagnostikimin e rritjes së kujtesës në shërbimet afatgjate dhe për të shkruar kod të ndërgjegjshëm ndaj kujtesës — të njohuri se se rregulla zakonisht përfshin thyrjen e referencave (kufizimet e cache-it, pastrimin e regjistrimit) sesa ndonjë gjë që GC-ja mund të bëjë për ju.