Bagaimanakah Go menguruskan memori dan pengumpulan sampah?

Question

Accepted Answer

Go **menguruskan memori secara automatik** dengan pengumpul sampah (garbage collector), membebaskan anda daripada peruntukan/pembebasan manual. GC-nya ialah pengumpul **mark-and-sweep serentak, kependaman rendah, bukan generasi** yang direka untuk meminimumkan masa jeda — sebab utama Go sesuai untuk perkhidmatan sensitif kependaman.

## Stack lawan heap dan analisis escape

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

Pengkompil Go melakukan **analisis escape** pada masa kompil: nilai yang tidak melebihi hayat fungsinya kekal pada **stack** yang murah dan dibebaskan secara automatik; nilai yang rujukannya escape akan ke **heap** (di mana GC menguruskannya). Peruntukan stack pada dasarnya percuma, jadi meminimumkan escape ke heap mengurangkan kerja GC.

## Pengumpul sampah: mark-and-sweep serentak

```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 dengan sengaja mengutamakan **masa jeda rendah** berbanding pemprosesan mentah — GC melakukan kebanyakan kerja secara serentak dengan program anda, mengekalkan jeda "stop-the-world" yang sangat pendek. Ini menjadikan Go kuat untuk pelayan sensitif kependaman.

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

## Mengurangkan tekanan GC (teknik prestasi)

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

Lebih sedikit peruntukan = lebih sedikit kerja GC. `sync.Pool` (penggunaan semula objek), pra-peruntukan, dan meminimumkan escape ialah cara utama untuk mengurangkan tekanan GC dalam laluan panas.

## Kebocoran memori masih berlaku

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

## Mengapa ia penting

Pengurusan memori automatik Go ialah kemenangan besar dari segi produktiviti dan keselamatan (tiada free manual, tiada penunjuk tergantung), tetapi memahami *bagaimana* ia berfungsi adalah berharga untuk aplikasi kritikal prestasi dan sensitif kependaman — yang Go sering dipilih untuknya.

Wawasan utama: **analisis escape** menentukan peruntukan stack lawan heap (stack percuma; meminimumkan escape ke heap mengurangkan kerja GC), dan GC **serentak, kependaman rendah** Go mengutamakan jeda pendek berbanding pemprosesan (ideal untuk pelayan, tidak seperti pengumpul yang berfokus pemprosesan).

Mengetahui cara mengurangkan tekanan GC (`sync.Pool`, pra-peruntukan, lebih sedikit peruntukan dalam laluan panas), menalanya (`GOGC`, `GOMEMLIMIT`), dan menyedari bahawa **kebocoran masih berlaku** daripada rujukan yang berlarutan (terutamanya kebocoran goroutine) adalah penting untuk mengendalikan perkhidmatan Go berprestasi tinggi.

Ini pengetahuan mendalam dan praktikal yang membezakan pembangun Go senior dan merupakan topik temu duga lanjutan yang biasa untuk peranan sensitif prestasi.