Kako Go upravlja pomnilnik in zbiranje smeti?

Question

Accepted Answer

Go **samodejno upravlja pomnilnik** s zbiralnikom smeti, kar vas osvoboди ročnega dodeljevanja in sproščanja. Njegov GC je **sočasni, niskonizkonizkosekundni, ne-generacijski mark-and-sweep** zbiralek, zasnovan za minimiziranje časa pauz — ključni razlog, zakaj je Go primeren za storitve občutljive na zakasnitve.

## Sklad proti stogu in analiza pobega

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

Kompajler Go-ja izvede **analizo pobega** ob času prevajanja: vrednosti, ki ne preživijo svoje funkcije, ostanejo na poceni, samodejno osvobojeni **skladu**; vrednosti, katerih reference pobegnejo, gredo na **stog** (kjer GC upravlja njimi). Dodeljevanje skladu je v bistvu brezplačno, zato zmanjšanje pobegov na stog zmanjšuje delo GC-ja.

## Zbiralek smeti: sočasni 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 namerno daje prednost **nizkim časom pauz** pred surovo prepustnostjo — GC večino dela izvede sočasno z vašim programom, pri čemer ostanejo "stop-the-world" pause zelo kratke. To naredi Go močan za strežnike občutljive na zakasnitve.

## Umerjanje GC-ja

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

## Zmanjšanje tlaka na GC (tehnika za zmogljivost)

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

Manj dodeljevanja = manj dela GC-ja. `sync.Pool` (ponovno uporabo objektov), preddobdeljevanje in minimiziranje pobegov so glavni načini za zmanjšanje tlaka na GC v horkých poteh.

## Puščave pomnilnika se še vedno dogajajo

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

## Zakaj je to pomembno

Samodejno upravljanje pomnilnika Go-ja je velika zmaga v produktivnosti in varnosti (brez ročnega sproščanja, brez viseče pokazivače), vendar razumevanje *kako* deluje je dragoceno za aplikacije kritične za zmogljivost in zakasnitve — za katere je Go pogosto izbran.

Ključni vpogled: **analiza pobega** určuje dodeljevanje skladu proti stogu (sklad je brezplačen; minimiziranje pobegov na stog zmanjšuje delo GC-ja) in Go-jev **sočasni, niskonizkosekundni GC** daje prednost kratkim pauzam pred prepustnostjo (idealno za strežnike, za razliko od zbiralkov usmerenih v prepustnost).

Znanje, kako zmanjšati tlak na GC (`sync.Pool`, preddobdeljevanje, manj dodeljevanja v gorkočih zankah), ga umerjati (`GOGC`, `GOMEMLIMIT`) in prepoznati, da se **puščave še vedno dogajajo** od trajnih referenc (posebej puščave gorutine), je pomembno za upravljanje visoko zmogljivih Go-jevih storitev.

To je globoko, praktično znanje, ki razlikuje starejše Go-jeve razvijalce in je pogosta napredna tema intervjuja za vloge občutljive na zmogljivost.