Bagaimana Go mengelola memori dan garbage collection?

Question

Accepted Answer

Go **secara otomatis mengelola memori** dengan garbage collector, membebaskan Anda dari alokasi/pembebasan manual. GC-nya adalah **concurrent, low-latency, non-generational mark-and-sweep** collector yang dirancang untuk meminimalkan pause times — alasan utama Go cocok untuk layanan yang sensitif terhadap latency.

## Stack vs heap dan 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
}
```

Kompiler Go melakukan **escape analysis** pada waktu kompilasi: nilai-nilai yang tidak bertahan lebih lama dari fungsi mereka tetap di **stack** yang murah dan otomatis dibebaskan; nilai-nilai yang referensinya escape ke **heap** (di mana GC mengelolanya). Alokasi stack pada dasarnya gratis, jadi meminimalkan heap escapes mengurangi pekerjaan 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 dengan sengaja memprioritaskan **pause times rendah** daripada throughput murni — GC melakukan sebagian besar pekerjaan secara concurrent dengan program Anda, menjaga pause "stop-the-world" sangat singkat. Ini membuat Go kuat untuk server yang sensitif terhadap latency.

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

## Mengurangi GC pressure (teknik performance)

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

Semakin sedikit alokasi = semakin sedikit pekerjaan GC. `sync.Pool` (reuse object), preallocation, dan meminimalkan escapes adalah cara utama untuk mengurangi GC pressure di hot paths.

## Memory leaks masih terjadi

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

Manajemen memori otomatis Go adalah kemenangan produktivitas dan keamanan yang besar (tidak ada free manual, tidak ada dangling pointers), tetapi memahami *bagaimana* cara kerjanya berharga untuk aplikasi yang performance-critical dan latency-sensitive — yang Go sering dipilih untuk itu.

Wawasan kunci: **escape analysis** menentukan alokasi stack vs heap (stack gratis; meminimalkan heap escapes mengurangi pekerjaan GC), dan **concurrent, low-latency GC** Go memprioritaskan pause singkat daripada throughput (ideal untuk server, tidak seperti collector yang fokus throughput).

Mengetahui cara mengurangi GC pressure (`sync.Pool`, preallocation, sedikit alokasi di hot loops), mengaturnya (`GOGC`, `GOMEMLIMIT`), dan menyadari bahwa **leaks masih terjadi** dari referensi yang tertinggal (terutama goroutine leaks) penting untuk mengoperasikan layanan Go berkinerja tinggi.

Ini adalah pengetahuan mendalam dan praktis yang membedakan developer Go senior dan adalah topik advanced interview yang umum untuk peran performance-sensitive.