Cum gestionează Go memoria și colectarea deșeurilor?

Question

Accepted Answer

Go **gestionează automat memoria** cu un colector de deșeuri, eliberîndu-te de alocarea/liberarea manuală. GC-ul său este un colector **concurrent, cu latență scăzută, non-generațional mark-and-sweep** conceput pentru a minimiza timpii de pauză — un motiv cheie pentru care Go se potrivește serviciilor sensibile la latență.

## Stack versus heap și analiza de evadare

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

Compilerul Go efectuează **analiza de evadare** la timp de compilare: valorile care nu trăiesc mai mult decât funcția lor rămân pe **stack**-ul ieftin, eliberat automat; valorile ale căror referințe se evadează merg pe **heap** (unde GC-ul le gestionează). Alocarea pe stack este esențial gratuită, deci minimizarea evadărilor pe heap reduce munca GC-ului.

## Colectorul de deșeuri: mark-and-sweep concurrent

```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 prioritizează deliberat **timpii de pauză scuți** peste productivitate brută — GC-ul execută cea mai mare parte a muncii concurrently cu programul tău, păstrând pauzele "stop-the-world" foarte scurte. Aceasta face Go puternic pentru servere sensibile la latență.

## Ajustarea GC-ului

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

## Reducerea presiunii GC (tehnica de performanță)

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

Mai puține alocări = mai puțină muncă GC. `sync.Pool` (reutilizarea obiectelor), preallocarea și minimizarea evadărilor sunt principalele moduri de a reduce presiunea GC în căi critice.

## Scurgerile de memorie încă se întâmplă

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

## De ce contează

Gestionarea automată a memoriei în Go este o victorie majoră în productivitate și siguranță (fără liberare manuală, fără pointeri atârnători), dar înțelegerea *cum* funcționează este valoroasă pentru aplicațiile critice de performanță și sensibile la latență — pentru care Go este adesea ales.

Idei cheie: **analiza de evadare** determină alocarea stack versus heap (stack este gratuit; minimizarea evadărilor pe heap reduce munca GC-ului) și GC-ul concurrect, cu latență scăzută **al lui Go** prioritizează pauzele scurte peste productivitate (ideal pentru servere, spre deosebire de colectoarele orientate spre productivitate).

Cunoașterea cum să reducă presiunea GC (`sync.Pool`, preallocarea, mai puține alocări în buclele critice), să o ajusteze (`GOGC`, `GOMEMLIMIT`) și recunoașterea că **scurgerile se produc încă** din referințele persistente (în special scurgeri de goroutine) este importantă pentru operarea serviciilor Go de înaltă performanță.

Aceasta este cunoaștere profundă și practică care deosebește dezvoltatorii Go seniori și este un subiect comun de interview avansat pentru roluri sensibile la performanță.