goroutine leaks को कारण के हुन्छ र तपाइँले तिनलाई कसरी रोक्न सक्नुहुन्छ?

Question

Accepted Answer

एक **goroutine leak** एक goroutine हो जो कहिले पनि समाप्त हुँदैन — यो अवरुद्ध वा सधैं चलिरहन्छ, मेमोरी खपत गर्दै (र यसले सन्दर्भित वस्तुहरूलाई जीवित राखे) प्रोग्रामको जीवनकालका लागि। गोरुटिनहरू सुरु गर्न सस्ता भएकोले, तिनलाई leak गर्न सजिलो छ, र leaks मौनतापूर्वक संचय हुन्छ जबसम्म सेवा खराब हुँदैन वा मेमोरी समाप्त हुँदैन।

## कारण 1: channel मा अवरुद्ध, कोन 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 जो channel send/receive मा अवरुद्ध छ जो कहिले पूरा हुँदैन **सधैं** प्रतीक्षा गर्नेछ — यो कहिले garbage collect हुँदैन किनभने यो प्रविधिगतरूपमा अझै पनि "चलिरहेको" छ।

## कारण 2: कोन 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
}
```

## रोकथाम 1: cancellation का लागि 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 बन्द गर्नुहोस् / तिनलाई सही तरिकाले drain गर्नुहोस्

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

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

`runtime.NumGoroutine()` अनुगमन गर्दै (एक स्थिर रूपमा बढ्दो गणनी एक leak को संकेत गर्दछ), `pprof` मार्फत goroutine dumps निरीक्षण गर्दै, र परीक्षणहरूमा `goleak` प्रयोग गर्दै मुख्य पत्ता लगाउने उपकरणहरू हुन्।

## किन यो महत्त्वपूर्ण छ

Goroutine leaks उत्पादन Go सेवाहरूमा सबैभन्दा सामान्य र सूक्ष्म समस्याहरू मध्ये एक हुन्।

गोरुटिनहरू लঞ्च गर्न यति सस्ता भएकोले, विकासकर्ताहरूले तिनलाई स्वतन्त्र रूपमा सिर्जना गर्छन् — तर एक goroutine सधैं अवरुद्ध (कोन समकक्ष वा infinite loop मा कोन cancellation सँग) **कहिले पनि समाप्त हुँदैन र यसको मेमोरी कहिले पनि छोड़दैन** (सबै कुरा सहित यो सन्दर्भ गर्दछ)।

दीर्घकालीन सर्भरमा, यी leaks मौनतापूर्वक संचय हुन्छ, क्रमशः मेमोरी खपत गर्दछ जबसम्म सेवा खराब हुँदैन वा क्र्यास हुँदैन — र तिनलाई पत्ता लगाउन गाह्रो छ किनभने कोन तत्काल त्रुटि छैन।

कारणहरू (अवरुद्ध channel अपरेसनहरू, मिसिङ cancellation) र रोकथामहरू (**context-आधारित cancellation** प्राथमिक सुरक्षाको रूपमा, उचित channel बन्द गर्ने, buffered channels, receivers सुनिश्चित गर्ने) बुझ्नु विश्वसनीय concurrent Go लेखन को लागि आवश्यक छ।

पत्ता लगाउने उपकरणहरू (`runtime.NumGoroutine`, pprof, goleak) को बारेमा जान्नु समान महत्त्वपूर्ण छ।

यो एक महत्त्वपूर्ण, बारम्बार-परीक्षित विषय हो जो उत्पादन-ग्रेड concurrent Go लेख्न सक्ने विकासकर्ताहरूलाई अलग गर्दछ ती लोकहरू बाट जो कोड लेख्छन् जो sustained load मा leak हुन्छ।