ਗੋਰਾਉਟੀਨ ਲੀਕ ਕਿਸ ਕਾਰਨ ਹੁੰਦੇ ਹਨ ਅਤੇ ਤੁਸੀਂ ਉਨ੍ਹਾਂ ਨੂੰ ਕਿਵੇਂ ਰੋਕਦੇ ਹੋ?

Question

Accepted Answer

A **goroutine leak** ਇਕ ਗੋਰਾਉਟੀਨ ਹੈ ਜੋ ਕਦੇ ਖਤਮ ਨਹੀਂ ਹੁੰਦਾ — ਇਹ ਬਲਾਕ ਹੋ ਕੇ ਰਹਿ ਜਾਂਦਾ ਹੈ ਜਾਂ ਹਮੇਸ਼ਾ ਲਈ ਚੱਲਦਾ ਰਹਿੰਦਾ ਹੈ, ਮੈਮੋਰੀ ਦੀ ਖਪਤ ਕਰਦਾ ਹੈ (ਅਤੇ ਆਪਣੇ ਸੰਦਰਭ ਕੀਤੇ ਆਬਜੈਕਟਾਂ ਨੂੰ ਜ਼ਿੰਦਾ ਰੱਖਦਾ ਹੈ) ਪ੍ਰੋਗ੍ਰਾਮ ਦੀ ਪੂਰੀ ਉਮਰ ਵਿੱਚ। ਕਿਉਂਕਿ goroutines ਸ਼ੁਰੂ ਕਰਨੇ ਮੋਹਰੇ ਹਨ, ਇਹ ਉਨ੍ਹਾਂ ਨੂੰ ਲੀਕ ਕਰਨਾ ਆਸਾਨ ਹੈ, ਅਤੇ ਲੀਕ ਚੁੱਪ ਚਾਪ ਜਮ੍ਹਾ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਤੱਕ ਸੇਵਾ ਘਾਟ ਦੀ ਨਹੀਂ ਹੁੰਦੀ ਜਾਂ ਮੈਮੋਰੀ ਖਤਮ ਨਹੀਂ ਹੋ ਜਾਂਦੀ।

## ਕਾਰਨ 1: ਚੈਨਲ 'ਤੇ ਬਲਾਕ ਜਿਸ ਕੋਲ ਭੇਜਣ ਵਾਲਾ/ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲਾ ਨਾ ਹੋ

```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 ਜੋ ਚੈਨਲ ਭੇਜਣ/ਪ੍ਰਾਪਤ ਕਰਨ 'ਤੇ ਬਲਾਕ ਹੈ ਜੋ ਕਦੇ ਪੂਰੀ ਨਹੀਂ ਹੁੰਦਾ **ਹਮੇਸ਼ਾ ਲਈ** ਉਡੀਕ ਕਰੇਗਾ — ਇਹ ਕਦੇ garbage ਵਾਸਤੇ ਇਕਤ੍ਰਿਤ ਨਹੀਂ ਹੁੰਦਾ ਕਿਉਂਕਿ ਇਹ ਤਕਨੀਕੀ ਤੌਰ 'ਤੇ ਅਜੇ ਵੀ "ਚੱਲ" ਰਿਹਾ ਹੈ।

## ਕਾਰਨ 2: ਕੋਈ ਰੱਦ ਨਹੀਂ / ਪੂਰੀ ਹੋ ਚੁੱਕੀ ਸਿਗਨਲ ਨਹੀਂ

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

## ਰੋਕਥਾਮ 1: ਰੱਦ ਕਰਨ ਲਈ context ਦੀ ਵਰਤੋਂ ਕਰੋ

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

ਹਰ ਲੰਬੇ ਸਮੇਂ ਵਾਲੇ goroutine ਨੂੰ ਰੱਦ ਕਰਨ ਦਾ ਤਰੀਕਾ ਦੇਣਾ (`<-ctx.Done()`) ਮੁੱਖ ਰਾਖਿਆ ਹੈ — ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ goroutines ਬੰਦ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਉਨ੍ਹਾਂ ਦੀ ਕਾਰਜ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ।

## ਰੋਕਥਾਮ 2: buffered channels ਜਾਂ 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
```

## ਰੋਕਥਾਮ 3: ਹਮੇਸ਼ਾ channels ਨੂੰ ਬੰਦ ਕਰੋ / ਉਨ੍ਹਾਂ ਨੂੰ ਸਹੀ ਤਰਾਂ ਡਰੇਨ ਕਰੋ

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

## ਲੀਕ ਖੋਜਣਾ

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

`runtime.NumGoroutine()` ਦੀ ਨਿਗਰਾਨੀ ਕਰਨਾ (ਇਕ ਲਗਾਤਾਰ ਵਧਦੀ ਗਣਨਾ ਲੀਕ ਦਾ ਸੰਕੇਤ ਹੈ), `pprof` ਦੁਆਰਾ goroutine ਡੰਪ ਦੀ ਜਾਂਚ ਕਰਨਾ, ਅਤੇ ਟੈਸਟਾਂ ਵਿੱਚ `goleak` ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਮੁੱਖ ਖੋਜ ਸਾਧਨ ਹਨ।

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰਖਦਾ ਹੈ

Goroutine ਲੀਕ ਪ੍ਰੋਡਕਸ਼ਨ Go ਸੇਵਾਵਾਂ ਵਿੱਚ ਸਭ ਤੋਂ ਆਮ ਅਤੇ ਭੁਲੇਖੇ ਭਰੀਆਂ ਸਮੱਸਿਆਵਾਂ ਵਿੱਚੋਂ ਇਕ ਹਨ।

ਕਿਉਂਕਿ goroutines ਲਾਂਚ ਕਰਨਾ ਬਹੁਤ ਸਸਤਾ ਹੈ, ਡਿਵੈਲਪਰ ਉਨ੍ਹਾਂ ਨੂੰ ਸੁਤੰਤਰਤਾ ਨਾਲ ਬਣਾਉਂਦੇ ਹਨ — ਪਰ ਇਕ goroutine ਜੋ ਹਮੇਸ਼ਾ ਲਈ ਬਲਾਕ ਹੈ (ਇਕ ਚੈਨਲ 'ਤੇ ਬਿਨਾ ਸਮਾਨਾਂਤਰ ਦੇ, ਜਾਂ ਇਕ ਅਨੰਤ ਲੂਪ ਵਿੱਚ ਬਿਨਾ ਰੱਦ ਦੇ) **ਕਦੇ ਖਤਮ ਨਹੀਂ ਹੁੰਦਾ ਅਤੇ ਕਦੇ ਆਪਣੀ ਮੈਮੋਰੀ ਜਾਰੀ ਨਹੀਂ ਕਰਦਾ** (ਉਸ ਸਮੇਂ ਸਭ ਕੁਝ ਸਮੇਤ)।

ਇਕ ਲੰਬੇ ਸਮੇਂ ਵਾਲੇ ਸਰਵਰ ਵਿੱਚ, ਇਹ ਲੀਕ ਚੁੱਪ ਚਾਪ ਜਮ੍ਹਾ ਹੁੰਦੇ ਹਨ, ਕਿਰਮਿਕ ਮੈਮੋਰੀ ਖਪਤ ਕਰਦੇ ਹਨ ਜਦੋਂ ਤੱਕ ਸੇਵਾ ਘਾਟ ਦੀ ਨਹੀਂ ਹੁੰਦੀ ਜਾਂ ਕ੍ਰੈਸ਼ ਨਹੀਂ ਹੁੰਦਾ — ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਖੋਜਣਾ ਔਖਾ ਹੈ ਕਿਉਂਕਿ ਕੋਈ ਤੁਰੰਤ ਗਲਤੀ ਨਹੀਂ ਹੁੰਦੀ।

ਕਾਰਨ ਸਮਝਨਾ (ਬਲਾਕ ਚੈਨਲ ਕਾਰਜ, ਨਿਖੇੜ ਰੱਦ) ਅਤੇ ਰੋਕਥਾਮ (**context-ਅਧਾਰਿਤ ਰੱਦ** ਮੁੱਖ ਰਾਖਿਆ ਦੇ ਰੂਪ ਵਿੱਚ, ਸਹੀ ਚੈਨਲ ਬੰਦ ਕਰਨਾ, buffered channels, receivers ਯਕੀਨੀ ਬਣਾਨਾ) ਕਿਫ਼ਾਇਤ ਨਾਲ concurrent Go ਲਿਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

ਖੋਜ ਸਾਧਨ ਜਾਣਨਾ (`runtime.NumGoroutine`, pprof, goleak) ਬਰਾਬਰ ਮਹੱਤਵਪੂਰਣ ਹੈ।

ਇਹ ਇਕ ਮਹੱਤਵਪੂਰਣ, ਅਕਸਰ-ਟੈਸਟ ਕੀਤਾ ਵਿਸ਼ਾ ਹੈ ਜੋ ਉਹ ਡਿਵੈਲਪਰ ਵੱਖ ਕਰਦਾ ਹੈ ਜੋ ਪ੍ਰੋਡਕਸ਼ਨ-ਗ੍ਰੇਡ concurrent Go ਲਿਖ ਸਕਦੇ ਹਨ ਉਨ੍ਹਾਂ ਤੋਂ ਜੋ ਸਸਟੇਨਡ ਲੋਡ ਦੇ ਅਧੀਨ ਲੀਕ ਕਰਨ ਵਾਲਾ ਕੋਡ ਲਿਖਦੇ ਹਨ।