Go मा सामान्य concurrent patterns के हुन्?

Question

Accepted Answer

Go को goroutines र channels ले well-established **concurrency patterns** को एक समूह सक्षम गर्छ जसले सामान्य समस्याहरू समाधान गर्छ — work distribute गर्ने, fanning out/in, pipelines, र rate limiting। यी idiomatic patterns जान्दा तपाई सही र efficient 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)
}
```

A **worker pool** ले fixed number को goroutines चलाउछ जसले shared jobs channel बाट consume गर्छ — concurrency bound गर्दै (जस्तै 10,000 DB connections खोल्नुहुन्न; 10 workers प्रयोग गर्नुहोस्)। यो resource usage नियन्त्रण गर्नको लागि सबैभन्दा महत्त्वपूर्ण pattern हो।

## 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 — stages connected by channels

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

A **pipeline** ले processing stages लाई channels मार्फत chain गर्छ — data stream हुन्छ, प्रत्येक stage ले यसलाई concurrently transform गर्छ।

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

## Cancellation with context (cross-cutting)

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

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

यी concurrency patterns real concurrent Go systems बनाउनको लागि practical toolkit हुन्, raw goroutines र channels लाई structured, correct solutions मा recurring problems को लागि परिणत गर्दै।

The **worker pool** विशेष रूपमा महत्त्वपूर्ण छ — यो concurrency लाई limited resources (database connections, API rate limits, memory) को सुरक्षा गर्न bound गर्छ, unbounded goroutines spawn गर्ने सामान्य गलती रोकदै जसले system exhaust गर्छ। **Fan-out/fan-in** ले work parallelize गर्छ र results merge गर्छ; **pipelines** ले streaming data transformations लाई cleanly model गर्छ; **rate limiting** ले throughput नियन्त्रण गर्छ।

**context-based cancellation** संग (goroutine leaks बचाउन), यी patterns production Go services मा safely र efficiently concurrency handle गर्ने तरिका हुन्।

यसलाई बुझ्न — र विशेष गरी worker pools संग bounded concurrency गर्न जान्न rather than launching unlimited goroutines — senior Go competence को hallmark हो र frequent advanced interview topic हो, किनभने naive concurrency (unbounded goroutines, leaks, races) production failures को common source हो।