როგორ იმართებს Python მეხსიერებას და garbage collection-ს?

Question

Accepted Answer

Python ქმნის მეხსიერებას **ავტომატიურად** ორი მექანიზმის გამოყენებით: **reference counting** (ძირითადი მეთოდი) და **cyclic garbage collector**, რომელიც reference cycles-ს ამუშავებს. თქვენ არასოდეს უშუალოდ თავისუფლდებთ მეხსიერებას, მაგრამ იმის გაგება, თუ როგორ მუშაობს, აიხსნის მეხსიერების ქცევას და გაჟონვას.

## 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 ატრაკებს რამდენი reference-ი მიუთითებს მას. როდესაც count დაეცემა **ნულამდე**, მეხსიერება **დაუყოვნებლივ** გათავისუფლდება. ეს დეტერმინისტიკური და მხეიმე — 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
```

ორი object, რომელიც ერთმანეთზე მიუთითებენ, აკეთებენ ერთმანეთის refcount-ს ნულზე მეტი, თუნდაც მიუწვდომელი იყოს — cycle, რომელიც pure reference counting-ს ვერ შეუძლია შეაგროვოს.

## The 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 უფრო ხშირად ემოწმება (ყველაზე ბევრი object ცხოვრობს ახალი), რაც ეფექტური.

## პრაქტიკული მნიშვნელობა & 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, რომელიც ჯერ კიდევ *reachable* — ჩვეულებრივი რეალური "leak" არის უნებლიეთ reference-ების ცხელ დაკავება (მაგ. ყოველთვის მზარდი 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-ის მეხსიერების მოდელის გაგება — მხეიმე reference counting плюс cyclic GC — აიხსნის რეალურ ქცევას: რატომ გათავისუფლდება objects ჩვეულებრივ დაუყოვნებლივ, რატომ სჭირდება reference cycles-ს GC და კრიტიკულად რატომ მოდის Python-ში "memory leaks" *reachable* reference-ებისგან (მზარდი caches, დარჩენილი closures, ამოუღებელი callbacks) ვიდრე დაკიდებული frees-ებიდან.

ეს ცოდნა აუცილებელია long-running services-ში მეხსიერების ზრდის დიაგნოსტიკისთვის და memory-conscious code-ის დასაწერად — იმის ცოდნა, რომ გამოსწორება ჩვეულებრივად reference-ების წაწყეტაა (bounding caches, registrations-ის გასუფთავება) ვიდრე რაიმე, რაც GC-ს ძალუფერი.