Me ke haifar da goroutine leaks kuma ta yaya za ka iya hana su?

Question

Accepted Answer

A **goroutine leak** shine goroutine wanda ba ya karewa – yana tsaye da taure ko yana gudana har abada, yana cinye ƙarfin ajiya (da kuma yana kiyaye abubuwan da ya ja) don gida mai tsanani. Saboda goroutines suna da jiya mai rashi na fara, yana da sauƙi a sa su tsarkace, kuma burgu suna tara sannu sannu har sai a sama aikin nau'i ko tsaye ƙarfin.

## Abin Haifar 1: tsaye da taure akan tsankwali inda babu abin aiki/mai karɓa

```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 wanda ya tsaye da taure kan ttankwali aiki/karɓa wanda ba zai gama ba zai jira **har abada** – ba ya samo kataccen bota saboda a zahiri yana cikin "gudana".

## Abin Haifar 2: babu sallace / done sigina

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

## Makamare 1: yi amfani da context don sallace

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

Ba da wata hanya da goroutine mai tsanani za ya iya sallace (`<-ctx.Done()`) shine babbar kariye – yana tabbatar da cewa goroutines suna karewa lokacin da aikinya ba shi bukatarwa.

## Makamare 2: yi amfani da tankwali mai mai maida ko tabbatar da mai karɓa

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

## Makamare 3: a koyaushe rufe tankwali / dren su daidai

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

## Gano burgu

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

Kulaito `runtime.NumGoroutine()` (lambar da ke tashi a hankali yana sada burgu), gilewa goroutine dumps ta `pprof`, da yin amfani da `goleak` a jeri sune kayan gano.