Ruby จัดการหน่วยความจำและ garbage collection อย่างไร?

Question

Accepted Answer

Ruby จัดการหน่วยความจำ **โดยอัตโนมัติ** ผ่าน **garbage collector (GC)** ที่เรียกคืนอ็อบเจกต์ที่ไม่ถูกอ้างอิงอีกต่อไป Ruby สมัยใหม่ (MRI) ใช้ตัวเก็บขยะแบบ **generational, incremental mark-and-sweep** พร้อมการ compaction การเข้าใจมันช่วยในเรื่องประสิทธิภาพและการวินิจฉัยปัญหาหน่วยความจำในแอปพลิเคชันที่ทำงานเป็นเวลานาน

## 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 ปลดคุณจากการจัดการหน่วยความจำด้วยตนเอง แนวทางแบบ **generational** (เก็บอ็อบเจกต์ใหม่บ่อย ๆ และราคาถูก ส่วนอ็อบเจกต์เก่านาน ๆ ที) ทำให้มันมีประสิทธิภาพ และการเก็บแบบ incremental ลดการหยุดชะงัก (pause)

## การตรวจสอบและปรับแต่ง 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 leak ยังคงเกิดขึ้นได้ (แม้จะมี 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.
```

## ทำไมจึงสำคัญ

การเข้าใจการจัดการหน่วยความจำและ garbage collection ของ Ruby เป็นความรู้ที่มีค่า โดยเฉพาะสำหรับ **แอปพลิเคชัน Ruby ที่ทำงานเป็นเวลานาน** (เช่น web server ของ Rails, background worker) ที่พฤติกรรมหน่วยความจำมีความสำคัญต่อความเสถียรและประสิทธิภาพ

แม้ว่า GC จะปลดคุณจากการจัดการหน่วยความจำด้วยตนเอง (ประโยชน์ด้านประสิทธิภาพการทำงานที่สำคัญ) แต่การเข้าใจ *ว่ามันทำงานอย่างไร* ช่วยในการปรับแต่งประสิทธิภาพและวินิจฉัยปัญหาหน่วยความจำ

การรู้ว่า Ruby สมัยใหม่ใช้ตัวเก็บขยะแบบ **generational, incremental, mark-and-sweep** (เก็บอ็อบเจกต์ใหม่บ่อย ๆ และราคาถูก ส่วนอ็อบเจกต์เก่านาน ๆ ที พร้อมกระจายงานเพื่อลดการหยุดชะงัก) ช่วยให้คุณคิดเกี่ยวกับพฤติกรรมและแรงกดดันของ GC ได้ และการรู้ว่าการ allocate อ็อบเจกต์มากเกินไปเพิ่ม overhead ของ GC (ดังนั้นการลดการ allocate ที่ไม่จำเป็นจะช่วยปรับปรุงประสิทธิภาพ)

ที่สำคัญอย่างยิ่ง การเข้าใจว่า **memory leak ยังคงเกิดขึ้นได้** แม้จะมี GC — เพราะ GC เก็บเฉพาะอ็อบเจกต์ที่ *ไม่สามารถเข้าถึงได้* (unreachable) ดังนั้น "leak" จึงมาจาก **การอ้างอิงที่ค้างอยู่** โดยไม่ตั้งใจ (collection ระดับ global หรือ class ที่โตขึ้นเรื่อย ๆ เช่น cache ที่ไม่มีขอบเขต; การอ้างอิงที่ถูกถือไว้ในอ็อบเจกต์ที่มีอายุยืน; อ็อบเจกต์ขนาดใหญ่ที่ถูก closure ทำให้ยังมีชีวิตอยู่) — เป็นสิ่งสำคัญสำหรับการวินิจฉัยและแก้ไขการเติบโตของหน่วยความจำที่รบกวนกระบวนการ Ruby ที่ทำงานเป็นเวลานาน (เป็นปัญหาในการปฏิบัติงานจริงที่พบบ่อย)

การรู้พฤติกรรมของ GC, วิธีตรวจสอบมัน (`GC.stat`, `ObjectSpace`), ตัวเลือกการปรับแต่ง และโดยเฉพาะอย่างยิ่งสาเหตุที่พบบ่อยของการเติบโตของหน่วยความจำ (การอ้างอิงที่ถูกถือไว้) มีค่าสำหรับการดำเนินงานแอปพลิเคชัน Ruby ที่มีประสิทธิภาพและเสถียร

เนื่องจากแอปพลิเคชัน Ruby (โดยเฉพาะ Rails server) ทำงานเป็นเวลานานและ memory leak จากการอ้างอิงที่ถูกถือไว้เป็นปัญหาในโลกจริงที่พบบ่อย การเข้าใจ GC ของ Ruby — โมเดล generational mark-and-sweep, ว่ามันไม่สามารถเก็บอ็อบเจกต์ที่เข้าถึงได้ และสาเหตุของการเติบโตของหน่วยความจำ — จึงเป็นความรู้ระดับ senior ที่สำคัญสำหรับประสิทธิภาพและความน่าเชื่อถือ แยกแยะนักพัฒนาที่สามารถวินิจฉัยและแก้ไขปัญหาหน่วยความจำใน Ruby ที่ทำงานจริง และเป็นหัวข้อที่เกี่ยวข้องสำหรับตำแหน่งที่เน้นประสิทธิภาพ