Go मध्ये सामान्य समवर्तिता नमुने काय आहेत?

Question

Accepted Answer

Go चे goroutines आणि channels एक सु-स्थापित **समवर्तिता नमुन्यांचा** संच सक्षम करतात जो सामान्य समस्याचे निराकरण करतो — कार्य वितरण, fan-out/fan-in, पाइपलाइन आणि दर मर्यादन. हे idiomatikउल नमुने जाणून, आप सही, कुशल समवर्ती प्रणाली तयार करू शकता.

## हे महत्वाचे का आहे

```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** निश्चित संख्येच्या goroutines चलाता जो साझा jobs channel मधून ग्रहण करतात — समवर्तिता बंधन आहे (उदा. 10,000 DB कनेक्शन उघडू नका; 10 कामगार वापरा). ही संसाधन वापरण्याचे नियंत्रण करण्यासाठी सर्वात महत्वाचे नमुना आहे.

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

एक **pipeline** प्रक्रिया टप्प्यांना channels द्वारे एकत्रित करता — डेटा प्रवाहित होता, प्रत्येक टप्पा त्याला समवर्तीपणे रूपांतरित करता.

## दर मर्यादन

```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 दर मर्यादा, स्मृति), अमर्यादित goroutines तयार करण्याचा सामान्य चूक टाळता ज्या प्रणाली संपवून टाकतात. **Fan-out/fan-in** कार्य समांतरित करते आणि परिणाम विलीन करते; **pipeline** प्रवाहित डेटा रूपांतरणांचे स्वच्छ मॉडेलिंग करते; **दर मर्यादन** throughput नियंत्रित करते.

**context-आधारित रद्दीकरणाच्या** संयोजनाने (goroutine गळती टाळण्यासाठी), हे नमुने उत्पादन Go सेवाएं समवर्तिता सुरक्षितपणे आणि कार्यक्षमतेने कसे हाताळतात त्याचे आहेत.

त्यांना समजणे — आणि विशेषत: अमर्यादित goroutines सुरू करण्याऐवजी worker pools सह समवर्तिता बंधन करण्यासाठी जाणून घेणे — हे ज्येष्ठ Go सक्षमतेचा हॉलमार्क आहे आणि एक वारंवार उन्नत साक्षात्कार विषय आहे, कारण सरल समवर्तिता (अमर्यादित goroutines, गळती, race) उत्पादन अपयशांचा सामान्य स्रोत आहे.