Go માં સામાન્ય સમવર্તિતા પેટર્ન કયા છે?

Question

Accepted Answer

Go ના goroutines અને channels એક સમૃદ્ધ **સમવર્તિતા પેટર્ન** સેટ સક્ષમ કરે છે જે સામાન્ય સમસ્યાઓ હલ કરે છે — કામનું વિતરણ, fanning out/in, pipelines અને rate limiting. આ મુહાવરાતી પેટર્નને જાણવાથી તમે સાચી, કાર્યક્ષમ સમવર્તી સિસ્ટમ બનાવી શકો છો.

## Worker pool — બંધાયેલ સમવર્તિતા

```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** નિશ્ચિત સંખ્યામાં goroutines ચલાવે છે જે સામાયિક jobs channel માંથી વાપર કરે છે — સમવર્તિતાને બાંધે છે (દા.ત. ૧૦,૦૦૦ DB સংযોગ ખોલશો નહીં; ૧૦ 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 દ્વારા જોડાયેલ તબક્કાઓ

```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** channels દ્વારા પ્રક્રિયાપુટ તબક્કાઓને શૃંખલબદ્ધ કરે છે — ડેટા પ્રવાહિત થાય છે, દરેક તબક્કો તેને સમવર્તી રીતે રૂપાંતરિત કરે છે.

## 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 સાથે રદ્દીકરણ (cross-cutting)

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

## શા માટે તે મહત્વપૂર્ણ છે

આ સમવર્તિતા પેટર્નને વાસ્તવિક સમવર્તી Go સિસ્ટમ બનાવવા માટે વ્યવહારુ સાધન કીટ છે, કાચા goroutines અને channels ને પુનરાવર્તી સમસ્યાઓના સુનિશ્ચિત, સાચા સમાધાનમાં ફેરવે છે.

**worker pool** ખાસ મહત્વપૂર્ણ છે — તે સમવર્તિતાને મર્યાદિત સંસાધનોને સુરક્ષિત કરવા માટે બાંધે છે (ડેટાબેસ સংયોગો, API rate limits, મેમરી), સીમાહીન goroutines બનાવવાની સામાન્ય ભૂલ અટકાવે છે જે સિસ્ટમને ખતમ કરે છે. **Fan-out/fan-in** કામને સમાંતર કરે છે અને પરિણામોને મર્જ કરે છે; **pipelines** સ્ટ્રીમિંગ ડેટા રૂપાંતરણોને સ્વચ્છતાથી મૉડલ કરે છે; **rate limiting** થ્રુપુટને નિયંત્રણમાં રાખે છે.

**context-આધારિત રદ્દીકરણ** (goroutine leaks ટાળવા માટે) સાથે જોડાયેલ, આ પેટર્નને production Go સેવાઓ સમવર્તિતાને સુરક્ષિત અને કાર્યક્ષમ રીતે હેન્ડલ કરે છે.

તેમને સમજવું — અને ખાસ કરીને સીમાહીન goroutines લঞ્ચ કરવાને બદલે worker pools સાથે સમવર્તિતાને બાંધવા જાણવું — વરિષ્ઠ Go સક્ષમતાનું ચિહ્ન છે અને વારંવાર અદ્યતન ઇન્ટરવ્યુ વિષય છે, કારણ કે નિષ્કપટ સમવર્તિતા (સીમાહીન goroutines, leaks, races) production નિષ્ફળતાનું સામાન્ય સ્ત્રોત છે.