Kaj povzroča puščanja gorutin in kako jih preprečiš?

Question

Accepted Answer

**Puščanje gorutin** je goroutina, ki se nikoli ne konča — ostane blokirana ali se izvaja neskončno, porablja pomnilnik (in drži živim njene referencijere objekte) za vse življenje programa. Ker so gorutine poceni za zagon, jih je enostavno pustiti, in puščanja se nakopičijo potiho, dokler se storitev ne poslabša ali porabi ves pomnilnik.

## Vzrok 1: blokirana na kanalu brez pošiljaoca/prejemnika

```go
// ❌ LEAK — this goroutine blocks forever waiting to send
func leak() {
    ch := make(chan int)   // unbuffered
    go func() {
        ch <- 42           // blocks forever — NOBODY ever receives
    }()                     // the goroutine is stuck, never exits
    // function returns without reading ch → the goroutine leaks
}
```

Goroutina blokirana na pošiljanju/prejemanju kanala, ki se nikoli ne zaključi, bo čakala **neskončno** — nikoli se je ne zbere po zakonu o odkupovanju, ker je tehnično še vedno "tekajoča".

## Vzrok 2: brez preklica / signala zaključka

```go
// ❌ LEAK — a goroutine in an infinite loop with no way to stop
func worker(jobs <-chan int) {
    for {
        job := <-jobs      // blocks forever if jobs is never closed and stops sending
        process(job)
    }                       // no exit condition — leaks when no longer needed
}
```

## Preprečevanje 1: uporaba konteksta za preklic

```go
// ✅ the goroutine can be told to stop
func worker(ctx context.Context, jobs <-chan int) {
    for {
        select {
        case job := <-jobs:
            process(job)
        case <-ctx.Done():       // cancellation signal → exit cleanly
            return                // the goroutine terminates, no leak
        }
    }
}
// caller: ctx, cancel := context.WithCancel(...); defer cancel()
```

Dajanje vsakega dolgoživega goroutina način, da ga prekličeš (`<-ctx.Done()`), je primarni zaščita — zagotavlja, da se gorutine zaključijo, ko njihovo delo ni več potrebno.

## Preprečevanje 2: uporaba polnjenih kanalov ali zagotavljanje prejemnikov

```go
// ✅ ensure a receiver exists, or use a buffered channel so the send doesn't block
ch := make(chan int, 1)   // buffered → the send completes even if no one receives yet
go func() { ch <- 42 }()   // doesn't block
```

## Preprečevanje 3: vedno zapri kanale / jih pravilno izprazni

```go
// ✅ close channels so range loops terminate
go func() {
    defer close(results)    // signal completion → for-range over results ends
    for _, job := range jobs { results <- process(job) }
}()
```

## Zaznavanje puščanj

```go
runtime.NumGoroutine()         // monitor the goroutine count — steady growth = leak
import _ "net/http/pprof"      // pprof exposes goroutine stacks (/debug/pprof/goroutine)
// the goleak library asserts no leaked goroutines in tests
```

Sprememljanje `runtime.NumGoroutine()` (neprekinjeno naraščajoči odbitek signalizira puščanje), pregled videnih gorutin preko `pprof` in uporaba `goleak` v testih so glavna orodja za zaznavanje.

## Zakaj je to pomembno

Puščanja gorutin so ena izmed najpogostejših in najbolj zvitih težav v proizvodnih servisih Go.

Ker so gorutine tako poceni za zagon, razvijalci jih ustvarjajo prosto — vendar je goroutina blokirana neskončno (na kanalu brez nasprotnega delca ali v neskončni zanki brez preklic) **nikoli se ne konča in nikoli ne sprosti svojega pomnilnika** (vključno z vsem, kar ima v referencah).

V dolgotrajnem strežniku se ta puščanja tiho nakopičijo, postopoma porabijo pomnilnik, dokler se storitev ne poslabša ali sesede — in jih je težko opaziti, ker ni takojšnje napake.

Razumevanje vzrokov (blokirana kanal operacijska, manjkajoč preklic) in preprečevanja (**preklic na osnovi konteksta** kot primarni zaščita, pravilno zaprtje kanalov, polnjeni kanali, zagotavljanje prejemnikov) je bistvenega pomena za pisanje zanesljivega sočasnega Go.

Znanje orodij za zaznavanje (`runtime.NumGoroutine`, pprof, goleak) je enako pomembno.

To je kritična, pogosto testirana tema, ki razlikuje razvijalce, ki znajo pisati proizvodnjsko kakovostni sočasni Go, od tistih, ki pišejo kodo, ki pušča pri trajni obremenitvi.