Kif Python jimmexxa l-memorja u l-garbage collection?

Question

Accepted Answer

Python jimmexxa l-memorja **awtomatikament** billi juża żewġ mekkaniżmi: **reference counting** (il-metodu primarju) flimkien ma' **cyclic garbage collector** li jħandel reference cycles. Qatt ma tħtieġ tħarreġ il-memorja manwalment, imma l-fehim ta' kif jaħdem jispjega l-imġiba tal-memorja u l-leaks.

## Reference counting — il-mekkaniżmu primarju

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

Kull object iżomm rekord ta' kemm references jippontaw għalih. Meta l-count jonqos għal **żero**, il-memorja tinħareġ **immedjatament**. Dan huwa deterministiku u vegħlien — objects immorru kuasi xejn ma jireference għalihom.

## Il-problema: 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
```

Zewġ objects li jireference lil xulxin iżommu l-refcount ta' xulxin 'il fuq minn żero anki meta ma jkunu jistgħu jintlaħqu — cycles li pure reference counting ma jistax ġabar.

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

Il-**generational garbage collector** supplimentali ta' Python detektazza u tħarreġ dawn il-cycles li ma jistgħu jintlaħqu b'mod perjodiċi. Huwa *generational* — objects ġodda jitħaqqqu aktar spiss (ħafna objects jmutu żagħżugħ), u dan huwa effiċjenti.

## Implikazzjonijiet prattiċi u sorsi ta' leaks

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

Il-GC jmexxu l-cycles, imma ma jistax ħarreġ objects li għad *reachable* — il-leak "real-world" komuni huwa li intenturi iżommu references ħajja (p.e. cache globali li tikber kontinwament).

## Dettalji oħra

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

## Għaliex hija importanti

Il-fehim tal-mudell ta' memorja ta' Python — reference counting vegħlien flimkien ma' cyclic GC — jispjega l-imġiba reali: għaliex objects normalment jinħarrġu immedjatament, għaliex reference cycles jeħtieġu l-GC, u kritikal għaliex "memory leaks" f'Python joħorġu minn *reachable* references (caches li jikbru, closures li idumu, callbacks li ma tnaqqsu) minflok minn forgotten frees.

Dan l-għarfien essenzjali biex tidiagnoza l-growtħ tal-memorja f'servizzi li jduru għal ħin twil u biex tikteb kodiċi li jaħseb fuq il-memorja — l-għarfien li l-fix normalment huwa tal-waqfien ta' references (bounding caches, nadif ta' registrazzjonijiet) minflok xi ħaġa li l-GC jista' jagħmel għalik.