Piye carane Go ngelola memori lan garbage collection?

Question

Accepted Answer

Go **automatically manages memory** karo garbage collector, mebebaske sampeyan saka manual allocation/freeing. GC-ne yaiku **concurrent, low-latency, non-generational mark-and-sweep** collector sing dirancang kanggo nyilikke pause times — alasan kunci Go cocok kanggo layanan sing peka latency.

## Stack vs heap lan 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 nindakake **escape analysis** ing compile time: values sing ora dawa minangka function tetep ing stack sing murah, automatically-freed **stack**; values sing reference-ne escape lunga menyang **heap** (kana GC ngelola). Stack allocation praktis gratis, dadi nyilikke heap escapes nyilikke GC work.

## 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 kanthi sengaja nge-prioritas **low pause times** tinimbang raw throughput — GC nindakake paling kathah work secara concurrent karo program sampeyan, ngedhol "stop-the-world" pauses sangat pendek. Iki nggawe Go kuat kanggo servers sing peka 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
```

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

Alokasi sing luwih sithik = GC work sing luwih sithik. `sync.Pool` (reuse objects), preallocation, lan nyilikke escapes minangka cara utama kanggo nyilikke GC pressure ing hot paths.

## Memory leaks tetep kedadi

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

Automatic memory management Go minangka kemenangan produktivitas lan safety utama (ora manual free, ora dangling pointers), nanging ngerti *endi* work-e iku berharga kanggo aplikasi performance-critical lan latency-sensitive — kang Go asring dipilih.

Insight kunci: **escape analysis** nemtokke stack vs heap allocation (stack iku gratis; nyilikke heap escapes nyilikke GC work), lan **concurrent, low-latency GC** Go nge-prioritas short pauses tinimbang throughput (ideal kanggo servers, beda karo throughput-focused collectors).

Melok carane nyilikke GC pressure (`sync.Pool`, preallocation, alokasi luwih sithik ing hot loops), tune-ne (`GOGC`, `GOMEMLIMIT`), lan ngenali bilih **leaks tetep kedadi** saka lingering references (khususé goroutine leaks) penting kanggo nglakokake high-performance Go services.

Iki pengetahuan dalam, praktikal sing mbedakke senior Go developers lan minangka topik advanced interview umum kanggo performance-sensitive roles.