Kas sukelia goroutine nuotėkius ir kaip juos išvengti?

Question

Accepted Answer

A **goroutine leak** yra goroutine, kuris niekada nenutrūksta — jis lieka užblokuotas arba veikia amžinai, vartodamas atmintį (ir išlaikydamas gyvi jo nurodytus objektus) per visą programos laiką. Kadangi goroutinai yra pigūs paleidžiami, juos lengva nutekinti, o nuotėkiai kaupimis tyliai, kol paslauga sutrikdo arba baigsis atmintis.

## Priežastis 1: užblokuotas kanale be siuntėjo/imtuvo

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

Goroutine, kuris yra užblokuotas kanalo siuntimui/gavimui, kuris niekada nebaigsis, lauks **amžinai** — jis niekada nebus išvalomas kaip atliekos, nes techniškai vis dar yra "veikiantis".

## Priežastis 2: nėra atšaukimo / baigties signalo

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

## Prevencion 1: naudoti context atšaukimui

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

Sudavus kiekvienam ilgalaikiam goroutinui būdą būti atšauktam (`<-ctx.Done()`), tai yra pagrindinė apsauga — tai užtikrina, kad goroutinai nutrūksta, kai jų darbas nebereikalingas.

## Prevencion 2: naudoti buferizuotus kanalus arba užtikrinti imtuvus

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

## Prevencion 3: visada uždaryti kanalus / juos tinkamai išpumpuoti

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

## Nuotėkių aptikimas

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

Stebėti `runtime.NumGoroutine()` (nuolat didėjantis skaičius signalizuoja nuotėkį), apžiūrėti goroutine nurodimus per `pprof`, ir naudoti `goleak` testuose yra pagrindiniai aptikimo įrankiai.

## Kodėl tai svarbu

Goroutine nuotėkiai yra viena iš dažniausių ir pačių neapčiaupiamų problemų produkcijos Go paslaugose.

Nes goroutinai yra tokie pigūs paleisti, kūrėjai juos kuria laisvai — bet goroutine, kuris yra užblokuotas amžinai (kanale be atitikmens, arba begalinėje kilpoje be atšaukimo), **niekada nenutrūksta ir niekada neišlaisvina savo atminties** (įskaitant viską, ką jis nurodo).

Ilgalaikėje serveryje šie nuotėkiai kaupiasi tyliai, laipsniškai vartodami atmintį, kol paslauga sutrikdo arba sugriūna — ir juos sunku pastebėti, nes nėra iškarto klaidos.

Supratimas priežasčių (užblokuotos kanalo operacijos, praleistas atšaukimas) ir prevencinės strategijos (**context pagrįstas atšaukimas** kaip pagrindinė apsauga, tinkamas kanalo uždarymas, buferizuoti kanalai, imtuvų užtikrinimas) yra būtinas, norint parašyti patikimą lygiagrečią Go kodą.

Žinojimas aptikimo įrankių (`runtime.NumGoroutine`, pprof, goleak) yra vienodai svarbus.

Tai kritinė, dažnai testuojama tema, kuri skiria kūrėjus, galinčius rašyti produkcijos kokybės lygiagrečią Go, iš tų, kurie rašo kodą, kuris nuteka esant ilgalaikei apkrovai.