Bagaimana Ruby menguruskan memori dan garbage collection?

Question

Accepted Answer

Ruby menguruskan memori **secara automatik** melalui **garbage collector (GC)** yang menuntut semula objek yang tidak lagi dirujuk. Ruby moden (MRI) menggunakan collector **mark-and-sweep generasi dan inkremental** dengan pemadatan. Memahaminya membantu dengan prestasi dan mendiagnosis isu memori dalam aplikasi yang berjalan lama.

## Garbage collection automatik

```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 membebaskan anda daripada pengurusan memori manual. Pendekatan **generasi** (mengumpul objek muda dengan kerap dan murah, objek lama jarang) menjadikannya cekap, dan pengumpulan inkremental mengurangkan jeda.

## Memeriksa dan menala 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.
```

## Kebocoran memori masih berlaku (walaupun ada 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.
```

## Mengapa ia penting

Memahami pengurusan memori dan garbage collection Ruby ialah pengetahuan yang bernilai, terutamanya untuk **aplikasi Ruby yang berjalan lama** (seperti pelayan web Rails, background worker) di mana tingkah laku memori penting untuk kestabilan dan prestasi.

Walaupun GC membebaskan anda daripada pengurusan memori manual (manfaat produktiviti yang besar), memahami *bagaimana* ia berfungsi membantu dengan penalaan prestasi dan mendiagnosis masalah memori.

Mengetahui bahawa Ruby moden menggunakan collector **mark-and-sweep generasi dan inkremental** (mengumpul objek muda dengan kerap dan murah, objek lama jarang, sambil menyebarkan kerja untuk mengurangkan jeda) membantu anda menaakul tentang tingkah laku dan tekanan GC, dan bahawa pengalokasian objek yang berlebihan meningkatkan overhead GC (jadi mengurangkan pengalokasian yang tidak perlu boleh meningkatkan prestasi).

Yang kritikal, memahami bahawa **kebocoran memori masih berlaku** walaupun ada GC — kerana GC hanya membebaskan objek *tidak boleh dicapai*, jadi "kebocoran" datang daripada **rujukan yang berlarutan** yang tidak disengajakan (koleksi peringkat global atau class yang hanya membesar, seperti cache tanpa had; rujukan yang dipegang dalam objek berjangka panjang; objek besar yang dikekalkan hidup oleh closure) — adalah penting untuk mendiagnosis dan membaiki pertumbuhan memori yang merosakkan proses Ruby yang berjalan lama (masalah operasi sebenar yang lazim).

Mengetahui tingkah laku GC, cara memeriksanya (`GC.stat`, `ObjectSpace`), pilihan penalaan, dan terutamanya punca lazim pertumbuhan memori (rujukan yang dikekalkan) adalah bernilai untuk mengendalikan aplikasi Ruby yang berprestasi dan stabil.

Memandangkan aplikasi Ruby (terutamanya pelayan Rails) berjalan untuk tempoh yang lama dan kebocoran memori daripada rujukan yang dikekalkan ialah isu dunia sebenar yang kerap, memahami GC Ruby — model mark-and-sweep generasinya, bahawa ia tidak boleh membebaskan objek boleh dicapai, dan punca pertumbuhan memori — ialah pengetahuan peringkat senior yang penting untuk prestasi dan kebolehpercayaan, membezakan pembangun yang boleh mendiagnosis dan membaiki isu memori dalam Ruby production, serta topik yang relevan untuk peranan yang berfokus pada prestasi.