आम Go concurrency पैटर्न क्या हैं?

Question

Accepted Answer

Go की goroutines और channels कई सुस्थापित **concurrency पैटर्न** सक्षम करते हैं जो आम समस्याओं को हल करते हैं — काम वितरित करना, fan-out/in, pipelines, और rate limiting। इन idiomatic पैटर्नों को जानना आपको सही, कुशल concurrent systems बनाने देता है।

## worker pool — bounded concurrency

```go
func workerPool(jobs <-chan int, results chan<- int, numWorkers int) {
    var wg sync.WaitGroup
    for w := 0; w < numWorkers; w++ {     // a FIXED number of workers
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {        // each worker pulls jobs until the channel closes
                results <- process(job)
            }
        }()
    }
    wg.Wait()
    close(results)
}
```

एक **worker pool** एक साझा jobs channel से उपभोग करने वाली निश्चित संख्या में goroutines चलाता है — concurrency को सीमित करते हुए (जैसे 10,000 DB connections न खोलें; 10 workers का उपयोग करें)। यह संसाधन उपयोग को नियंत्रित करने का सबसे महत्वपूर्ण पैटर्न है।

## fan-out / fan-in

```text
Fan-out: distribute work across MULTIPLE goroutines (parallelize)
Fan-in:  MERGE results from multiple goroutines back into one channel
```

```go
// fan-in: merge several channels into one
func merge(channels ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    for _, ch := range channels {
        wg.Add(1)
        go func(c <-chan int) {
            defer wg.Done()
            for v := range c { out <- v }   // forward each channel's values to out
        }(ch)
    }
    go func() { wg.Wait(); close(out) }()    // close out when all sources are drained
    return out
}
```

## pipeline — channels द्वारा जुड़े stages

```go
// each stage is a goroutine: receives from an input channel, sends to an output channel
func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() { for _, n := range nums { out <- n }; close(out) }()
    return out
}
func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() { for n := range in { out <- n * n }; close(out) }()
    return out
}
// compose: square(generate(1,2,3)) → a streaming pipeline
for result := range square(generate(1, 2, 3)) { fmt.Println(result) }
```

एक **pipeline** processing stages को channels के माध्यम से जोड़ता है — data इसके बीच से बहता है, हर stage इसे समानांतर रूप से रूपांतरित करता है।

## rate limiting

```go
limiter := time.Tick(200 * time.Millisecond)   // a tick every 200ms
for req := range requests {
    <-limiter                                    // wait for the next tick before proceeding
    go handle(req)                                // → at most 5 requests/second
}
```

## context के साथ cancellation (cross-cutting)

```go
select {
case result := <-work:
case <-ctx.Done():    return   // stop on cancellation — prevents leaks
}
```

## यह क्यों महत्वपूर्ण है

ये concurrency पैटर्न वास्तविक concurrent Go systems बनाने के लिए व्यावहारिक toolkit हैं, जो कच्ची goroutines और channels को बार-बार आने वाली समस्याओं के संरचित, सही समाधानों में बदल देते हैं।

**worker pool** विशेष रूप से महत्वपूर्ण है — यह सीमित संसाधनों (database connections, API rate limits, memory) की रक्षा के लिए concurrency को सीमित करता है, जो असीमित goroutines spawn करने की आम गलती को रोकता है जो system को थका देती हैं। **fan-out/fan-in** काम को समानांतर करता है और results को merge करता है; **pipelines** streaming data रूपांतरणों को साफ़-सुथरे ढंग से मॉडल करते हैं; **rate limiting** throughput को नियंत्रित करता है।

**context-based cancellation** (goroutine leaks से बचने के लिए) के साथ मिलकर, ये पैटर्न ही हैं जिनसे production Go services सुरक्षित और कुशलता से concurrency संभालते हैं।

इन्हें समझना — और खासकर असीमित goroutines लॉन्च करने के बजाय worker pools से concurrency को सीमित करना जानना — senior Go दक्षता की एक पहचान है और एक बार-बार आने वाला advanced interview विषय है, क्योंकि भोली concurrency (असीमित goroutines, leaks, races) production failures का एक आम स्रोत है।