Ni nini husababisha goroutine leaks na unazuiaje?

Question

Accepted Answer

**Goroutine leak** ni goroutine ambayo haiishi kamwe — inabaki imezuiwa au inaendesha milele, ikitumia kumbukumbu (na kuweka objects zake zinazorejewa hai) kwa maisha yote ya programu. Kwa kuwa goroutines ni za bei nafuu kuanzisha, ni rahisi kuzi-leak, na leaks hujilundika kimyakimya hadi huduma idhoofike au ikimalize kumbukumbu.

## Sababu 1: kuzuiwa kwenye channel bila sender/receiver

```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 iliyozuiwa kwenye channel send/receive ambayo haikamiliki kamwe itasubiri **milele** — haipati garbage collected kamwe kwa sababu kitaalamu bado "inaendesha."

## Sababu 2: hakuna cancellation / done signal

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

## Kuzuia 1: tumia context kwa cancellation

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

Kutoa kila goroutine inayoishi muda mrefu njia ya kufutwa (`<-ctx.Done()`) ndio ulinzi wa msingi — inahakikisha goroutines zinaisha wakati kazi yao haihitajiki tena.

## Kuzuia 2: tumia buffered channels au hakikisha kuna receivers

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

## Kuzuia 3: daima funga channels / zimwage ipasavyo

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

## Kugundua leaks

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

Kufuatilia `runtime.NumGoroutine()` (idadi inayopanda kwa kasi inaashiria leak), kukagua goroutine dumps kupitia `pprof`, na kutumia `goleak` katika tests ndizo zana kuu za kugundua.

## Kwa nini ni muhimu

Goroutine leaks ni mojawapo ya matatizo ya kawaida na hatari zaidi katika huduma za Go za uzalishaji.

Kwa sababu goroutines ni za bei nafuu sana kuanzisha, watengenezaji huziunda kwa uhuru — lakini goroutine iliyozuiwa milele (kwenye channel isiyo na mwenza, au katika infinite loop bila cancellation) **haiishi kamwe na haitoi kumbukumbu yake kamwe** (ikiwa ni pamoja na kila kitu inachorejea).

Katika server inayoendesha muda mrefu, leaks hizi hujilundika kimyakimya, hatua kwa hatua zikitumia kumbukumbu hadi huduma idhoofike au ianguke — na ni vigumu kuzigundua kwa sababu hakuna kosa la papo hapo.

Kuelewa sababu (operesheni za channel zilizozuiwa, cancellation iliyokosekana) na kuzuia (**cancellation inayotegemea context** kama ulinzi wa msingi, kufunga channels ipasavyo, buffered channels, kuhakikisha receivers) ni muhimu kwa kuandika Go ya concurrent yenye kuaminika.

Kujua zana za kugundua (`runtime.NumGoroutine`, pprof, goleak) ni muhimu vile vile.

Hii ni mada muhimu, inayojaribiwa mara kwa mara ambayo huwatofautisha watengenezaji wanaoweza kuandika Go ya concurrent ya kiwango cha uzalishaji na wale wanaoandika code inayo-leak chini ya mzigo endelevu.