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

Question

Accepted Answer

Go **จัดการหน่วยความจำโดยอัตโนมัติ** ด้วย garbage collector ทำให้คุณไม่ต้อง allocate/free เอง GC ของมันเป็น **concurrent, low-latency, non-generational mark-and-sweep** collector ที่ออกแบบมาเพื่อลดเวลาหยุดชะงัก (pause time) ให้น้อยที่สุด ซึ่งเป็นเหตุผลสำคัญที่ทำให้ Go เหมาะกับ service ที่อ่อนไหวต่อ latency

## Stack เทียบกับ heap และ escape analysis

```go
// the compiler decides where each value lives via ESCAPE ANALYSIS
func noEscape() int {
    x := 42        // stays on the STACK — doesn't escape, freed when function returns (cheap)
    return x
}
func escapes() *int {
    x := 42        // ESCAPES to the HEAP — its pointer outlives the function (GC-managed)
    return &x
}
```

compiler ของ Go ทำ **escape analysis** ในตอน compile: ค่าที่ไม่อยู่นานเกินกว่าฟังก์ชันของมันจะอยู่บน **stack** ที่ราคาถูกและถูก free อัตโนมัติ ส่วนค่าที่ reference ของมัน escape ออกไปจะอยู่บน **heap** (ซึ่ง GC เป็นผู้จัดการ) การ allocate บน stack แทบไม่มีต้นทุน ดังนั้นการลด heap escape จึงลดงานของ GC

## Garbage collector: concurrent mark-and-sweep

```text
Go's GC characteristics:
  ✓ MARK-AND-SWEEP — marks reachable objects (from roots), sweeps the rest
  ✓ CONCURRENT — runs mostly alongside your program (not stop-the-world)
  ✓ LOW LATENCY — optimized for short pauses (typically sub-millisecond), not throughput
  ✓ NON-GENERATIONAL — unlike the JVM, treats all objects uniformly (simpler)
```

Go จงใจให้ความสำคัญกับ **pause time ที่ต่ำ** มากกว่า throughput ดิบ ๆ GC ทำงานส่วนใหญ่แบบ concurrent ไปพร้อมกับโปรแกรมของคุณ จึงทำให้ช่วง "stop-the-world" สั้นมาก ทำให้ Go แข็งแกร่งสำหรับ server ที่อ่อนไหวต่อ latency

## การปรับแต่ง GC

```bash
GOGC=100   # default: trigger GC when heap grows 100% since the last collection
           # higher GOGC → less frequent GC (more memory, less CPU)
           # lower GOGC → more frequent GC (less memory, more CPU)
GOMEMLIMIT=2GiB   # a soft memory limit (Go 1.19+) — GC works harder near it
```

## ลดแรงกดดันต่อ GC (เทคนิคด้านประสิทธิภาพ)

```go
// 1. reuse objects with sync.Pool to reduce allocations
var bufPool = sync.Pool{New: func() any { return new(bytes.Buffer) }}
buf := bufPool.Get().(*bytes.Buffer)
defer bufPool.Put(buf)

// 2. preallocate slices with known capacity (avoid repeated growth/realloc)
data := make([]int, 0, 1000)

// 3. minimize heap escapes; avoid unnecessary pointers/allocations in hot loops
```

การ allocate น้อยลง = งานของ GC น้อยลง `sync.Pool` (การนำ object กลับมาใช้ใหม่), การ preallocate และการลด escape คือวิธีหลักในการลดแรงกดดันต่อ GC ใน hot path

## memory leak ยังเกิดขึ้นได้

```text
GC frees only UNREACHABLE objects. Leaks come from lingering REFERENCES:
  ✗ goroutine leaks (a blocked goroutine keeps its referenced memory alive)
  ✗ growing global maps/slices, unclosed resources, forgotten subscriptions
```

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

การจัดการหน่วยความจำอัตโนมัติของ Go เป็นชัยชนะครั้งใหญ่ด้าน productivity และความปลอดภัย (ไม่ต้อง free เอง ไม่มี dangling pointer) แต่การเข้าใจว่ามัน *ทำงานอย่างไร* มีคุณค่าสำหรับแอปพลิเคชันที่สำคัญต่อประสิทธิภาพและอ่อนไหวต่อ latency ซึ่งมักเป็นเหตุผลที่เลือกใช้ Go

ประเด็นสำคัญ: **escape analysis** กำหนดว่า allocate บน stack หรือ heap (stack ฟรี การลด heap escape ลดงานของ GC) และ GC ที่เป็น **concurrent, low-latency** ของ Go ให้ความสำคัญกับ pause สั้น ๆ มากกว่า throughput (เหมาะกับ server ไม่เหมือน collector ที่เน้น throughput)

การรู้วิธีลดแรงกดดันต่อ GC (`sync.Pool`, preallocation, การ allocate น้อยลงใน hot loop), การปรับแต่ง (`GOGC`, `GOMEMLIMIT`) และการตระหนักว่า **leak ยังเกิดขึ้นได้** จาก reference ที่ค้างอยู่ (โดยเฉพาะ goroutine leak) มีความสำคัญต่อการดำเนินงาน Go service ที่มีประสิทธิภาพสูง

นี่คือความรู้เชิงลึกและเชิงปฏิบัติที่แยกแยะนักพัฒนา Go ระดับ senior และเป็นหัวข้อสัมภาษณ์ขั้นสูงที่พบบ่อยสำหรับตำแหน่งที่อ่อนไหวต่อประสิทธิภาพ