Jak Go zarządza pamięcią i garbage collection?

Question

Accepted Answer

Go **automatycznie zarządza pamięcią** za pomocą garbage collectora, zwalniając Cię z ręcznego przydzielania/zwalniania pamięci. Jego GC to **współbieżny, niskoopcjonowy, nieogólny collector mark-and-sweep** zaprojektowany, aby zminimalizować czasy pauz — kluczowy powód, dla którego Go nadaje się do usług wrażliwych na opóźnienia.

## Stack a heap i analiza ucieczki

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

Kompilator Go wykonuje **analizę ucieczki** w czasie kompilacji: wartości, które nie przeżywają swojej funkcji, pozostają na tanim, automatycznie uwalnianym **stacku**; wartości, których referencje się wyrywają, trafiają na **heap** (gdzie GC nimi zarządza). Alokacja na stacku jest praktycznie darmowa, dlatego minimalizowanie ucieczek na heap zmniejsza pracę GC.

## Garbage collector: współbieżny 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 celowo priorytetyzuje **niskie czasy pauz** w stosunku do czystej przepustowości — GC wykonuje większość pracy współbieżnie z Twoim programem, utrzymując "stop-the-world" pauzy bardzo krótkie. To czyni Go silnym dla serwerów wrażliwych na opóźnienia.

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

## Zmniejszanie ciśnienia na GC (technika wydajności)

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

Mniej alokacji = mniej pracy dla GC. `sync.Pool` (ponowne użycie obiektów), prealokcja i minimalizowanie ucieczek to główne sposoby na zmniejszenie ciśnienia na GC w ścieżkach gorących.

## Wycieki pamięci się wciąż zdarzają

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

## Dlaczego to ważne

Automatyczne zarządzanie pamięcią Go to ogromny zysk w produktywności i bezpieczeństwie (brak ręcznego free, brak zawisłych wskaźników), ale zrozumienie *jak* to działa jest cenne dla aplikacji wrażliwych na wydajność i opóźnienia — do których Go jest często wybierane.

Kluczowe spostrzeżenia: **analiza ucieczki** określa alokację stack vs heap (stack jest darmowy; minimalizowanie ucieczek na heap zmniejsza pracę GC), a **współbieżny, niskoopcjonowy GC** Go priorytetyzuje krótkie pauzy w stosunku do przepustowości (idealne dla serwerów, w przeciwieństwie do collectorów zorientowanych na przepustowość).

Wiedza, jak zmniejszyć ciśnienie na GC (`sync.Pool`, prealokcja, mniej alokacji w gorących pętlach), dostroić go (`GOGC`, `GOMEMLIMIT`) i rozpoznać, że **wycieki się wciąż zdarzają** ze względu na utrzymujące się referencje (szczególnie wycieki goroutinów) jest ważna dla operowania wysokowydajnymi usługami Go.

To jest głęboka, praktyczna wiedza, która wyróżnia starszych programistów Go i jest częstym zaawansowanym tematem rozmowy kwalifikacyjnej dla ról wrażliwych na wydajność.