Kif Ruby jimexxax il-memorja u garbage collection?

Question

Accepted Answer

Ruby jimexxax il-memorja **awtomatikament** permezz ta' **garbage collector (GC)** li jirrikilma oġġetti li m'għadx hemm referenzi għalihom. Ruby modern (MRI) juża **generational, incremental mark-and-sweep** collector b'compaction. Fehim tiegħu jgħin mal-performance u d-dijanjożi ta' problemi tal-memorja f'applikazzjonijiet li jdumu għal żmien twil.

## Garbage collection awtomatiku

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

Il-GC jħallsak minn management manwali tal-memorja. L-approċċ **generational** (li jikkolletta oġġetti żgħar ta' spiss u bil-ħefef, antiki rari) jagħmilha effiċjenti, u l-incremental collection itnaqqas il-pauses.

## Inspektion u tuning ta' 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.
```

## Memory leaks iseħħu barra minn 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.
```

## Għaliex huwa importanti

Il-fehim tal-management tal-memorja Ruby u garbage collection huwa għarfien valjaż, partikolarment għal **applikazzjonijiet Ruby li jdumu għal żmien twil** (bħal Rails web servers, background workers) fejn il-ħtieġa tal-memorja importa għall-istabilità u l-performance.
"}}