Si menaxhon Go memorjen dhe mbledhjen e mbeturinave?

Question

Accepted Answer

Go **menaxhon memorjen automatikisht** me një mbledhës mbeturinash, duke të liruar nga alokimi/lirimi manual. GC-ja e tij është një mbledhës **i ngjashmërisë dhe pastrimit (mark-and-sweep), i njëkohshëm, me latencë të ulët, jo-gjeneracionale** i projektuar për të minimizuar kohën e pezullimit — një arsye kyçe përse Go është i përshtatshëm për shërbime të ndjeshme ndaj latencës.

## Stack kundrejt heap dhe analiza e ikjes

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

Kompajleri i Go-t kryen **analiza e ikjes** në kohën e kompajlimit: vlerat që nuk e tejkalojnë funksionin e tyre qëndrojnë në **stack**-un e lirë dhe të çliruar automatikisht; vlerat referimet e të cilave ikën shkojnë në **heap** (ku GC-ja i menaxhon ato). Alokimi i stack-ut është praktikisht i lirë, kështu që minimizimi i ikjeve të heap-ut zvogëlon punën e GC-së.

## Mbledhësi i mbeturinave: pastrimi i njëkohshëm i ngjashmërisë

```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 deliberatisht përqendrohet në **kohë pezullimi të ulët** në vend të produktivitetit të pastër — GC-ja bën shumicën e punës njëkohësisht me programin tuaj, duke mbajtur pezullimet "stop-the-world" shumë të shkurtra. Kjo e bën Go-n të fortë për shërbimet e ndjeshme ndaj latencës.

## Akordimi i GC-së

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

## Zvogëlimi i presionit të GC-së (teknika performante)

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

Më pak alokime = më pak punë GC. `sync.Pool` (ripërdorimi i objekteve), alokimi paraprak dhe minimizimi i ikjeve janë mënyrat kryesore për të zvogëluar presionin e GC-së në rrugat e nxehtë.

## Rrjedhjet e memorjes prapë ndodhin

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

## Pse ka rëndësi

Menaxhimi automatik i memorjes në Go-n është një fitore e madhe në produktivitet dhe siguri (pa lirimin manual, pa pointerë të vdekur), por kuptimi *i mënyrës se si* funksionon është i vlefshëm për aplikacionet kritike për performancën dhe të ndjeshme ndaj latencës — për të cilat Go shpesh zgjidhet.

Ideja kyçe: **analiza e ikjes** përcakton alokimin e stack kundrejt heap-ut (stack-u është i lirë; minimizimi i ikjeve të heap-ut zvogëlon punën e GC-sh), dhe **GC i njëkohshëm, me latencë të ulët** i Go-t përqendrohet në pezullime të shkurtra në vend të produktivitetit (ideal për shërbimet, ndryshe nga mbledhësit të fokusuar në produktivitet).

Dija se si të zvogëlohet presioni i GC-së (`sync.Pool`, alokimi paraprak, më pak alokime në sythe të nxehtë), ta akordohet atë (`GOGC`, `GOMEMLIMIT`), dhe të njohësh se **rrjedhjet prapë ndodhin** nga referencat e mbetjeve (veçanërisht rrjedhjet e goroutine) është e rëndësishme për funksionimin e shërbimeve Go me performancë të lartë.

Kjo është njohuri e thellë dhe praktike që dallon zhvillusit të moshuar të Go-t dhe është një temë e zakonshme e intervistës së përparuar për rolet e ndjeshme ndaj performancës.