Carane Ruby ngatur memori lan garbage collection?

Question

Accepted Answer

Ruby ngatur memori **otomatis** liwat **garbage collector (GC)** sing nglumpukake obyek-obyek sing ora dituding manèh. Ruby modern (MRI) nggunakaké **generational, incremental mark-and-sweep** collector sing ana kompaski. Ngerti babagan iki matulungi karo performa lan diagnosis masalah memori ing aplikasi sing dawa.

## Automatic garbage collection

```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 ngluwari sampeyan saka pengelolaan memori manual. Pendekatan **generational** (ngumpulake obyek muda asring lan murah, obyek lawas arang-arang) nggawake iku efisien, lan incremental collection nyuda pause.

## Inspecting dan tuning 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 isih kejadian (sanajan ana 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.
```

## Carane dadi penting

Ngerti pengelolaan memori Ruby lan garbage collection minangka pengetahuan sing berharga, utamane kanggo **aplikasi Ruby sing dawa** (kaya Rails web servers, background workers) kang tingkah laku memori penting kanggo stabilitas lan performa.

Sanajan GC ngluwari sampeyan saka pengelolaan memori manual (kauntungan produktivitas gedhe), ngerti *carane* iku bisa matulungi karo performance tuning lan diagnosis masalah memori.

Ngerti manawa Ruby modern nggunakaké **generational, incremental, mark-and-sweep** collector (ngumpulake obyek muda asring lan murah, obyek lawas arang-arang, nalika nebarake karya kanggo nyuda pause) matulungi sampeyan mikirake babagan tingkah laku GC lan tekanan, lan manawa alokasi obyek sing keterlaluan nambah overhead GC (dadi nyuda alokasi sing ora perlu bisa ningkatake performa).

Kritise, ngerti manawa **memory leaks isih bisa kejadian** sanajan ana GC — amarga GC mung nglumpukake obyek-obyek sing *ora dijangkau*, dadi "leaks" teka saka **lingering references** sing ora dikira-kira (global utawa class-level collections sing mung tuwuh, kaya unbounded caches; references sing didegake ing obyek sing urip dawa; obyek gedhe sing ana ing hidup dening closures) — penting kanggo diagnosis lan ngrukti memory growth sing medeni long-running Ruby processes (masalah nyata lan umum).

Ngerti tingkah laku GC, carane nginspeksi (`GC.stat`, `ObjectSpace`), opsi tuning, lan luwih-luwih penyebab umum memory growth (retained references) berharga kanggo ngoperasiake Ruby applications sing performan lan stabil.

Amarga Ruby applications (utamane Rails servers) mlaku kanggo periode dawa lan memory leaks saka retained references minangka masalah asring nyata, ngerti Ruby GC — generational mark-and-sweep model, manawa ora bisa nglumpukake obyek sing dijangkau, lan penyebab memory growth — penting senior-level knowledge kanggo performa lan reliability, mbedakake developers sing bisa diagnosis lan nerakaké masalah memori ing production Ruby, lan topic sing relevan kanggo roles sing fokus performa.