Kako Ruby upravlja spominom in s čiščenjem smeti (garbage collection)?

Question

Accepted Answer

Ruby upravlja spomin **samodejno** prek **zbierača smeti (GC)**, ki sprošča predmete, na katere se ne sklicuje več. Sodoben Ruby (MRI) uporablja **generacijski, inkrementalni zbierač tipa mark-and-sweep** s kompakrianjem. Razumevanje tega prispeva k izvedbi in diagnostiki težav s spomin v dolgotrajnih aplikacijah.

## Samodejno čiščenje smeti

```text
Ruby allocates objects on the heap; the GC reclaims those that are no longer REACHABLE
(referenced). You never free memory manually.

Modern MRI GC characteristics:
  ✓ Mark-and-sweep — marks reachable objects (from roots), sweeps unreachable ones
  ✓ Generational (since Ruby 2.1) — new objects collected often, old ones rarely
    (based on "most objects die young")
  ✓ Incremental — spreads GC work to reduce pause times
  ✓ Compacting (GC.compact, Ruby 2.7+) — reduces memory fragmentation
```

GC vas osvobodi ročnega upravljanja s spomin. **Generacijski** pristop (pogosto in poceni čiščenje mladih predmetov, redko starih) ga naredi učinkovitim, inkrementalno čiščenje pa zmanjša павze.

## Pregled in nastavljanje GC

```ruby
GC.stat                    # detailed GC statistics (counts, heap info)
GC.start                   # manually trigger a collection (rarely needed)
GC.compact                 # compact the heap (reduce fragmentation)
ObjectSpace.count_objects  # counts of objects by type (debugging)
# environment variables (RUBY_GC_*) tune heap growth, etc.
```

## Puščanja spomina se še vedno zgodijo (kljub GC)

```ruby
# the GC frees only UNREACHABLE objects — "leaks" come from lingering references:
$global_cache = []
def process(item)
  $global_cache << item    # ❌ grows forever — never freed (still referenced)
end
```

```text
Common Ruby memory-growth causes:
  ✗ Global/class-level collections that only grow (caches, arrays)
  ✗ References held in long-lived objects (constants, class variables)
  ✗ Large objects kept alive by closures/blocks
→ The GC can't free reachable objects, so "leaks" = unintended retained references.
```

## Zakaj je to pomembno

Razumevanje upravljanja spomina Ruby in čiščenja smeti je dragoceno znanje, posebej za **dolgotrajne Ruby aplikacije** (kot so Rails spletni strežniki, delavci v ozadju), kjer je vedenje memoria ključno za stabilnost in izvedbo.

Čeprav vas GC osvobodi ročnega upravljanja s spomin (kar je velika prednost produktivnosti), razumevanje *kako* deluje, pomaga pri prilagajanju izvedbe in diagnostiki težav s spomin.

Znanje, da sodoben Ruby uporablja **generacijski, inkrementalni zbierač tipa mark-and-sweep** (ki pogosto in poceni čisti mlade predmete in redko stare, medtem ko razprostira delo za zmanjšanje pavz), vam pomaga razumeti vedenje in pritisk GC, in da pretirani alokacije objektov povečajo GC režijo (zato zmanjšanje nepotrebnih alokacij lahko izboljša izvedbo).

Kritično je razumevanje, da se **puščanja spomina še vedno zgodijo** kljub GC — ker GC sprošča samo *nedosegljive* predmete, zato „puščanja