Go میں عام Concurrency Patterns کیا ہیں؟

Question

Accepted Answer

Go کے goroutines اور channels ایک سے زیادہ منطقی **concurrency patterns** فراہم کرتے ہیں جو عام مسائل کو حل کرتے ہیں — کام کی تقسیم، fanning out/in، pipelines، اور rate limiting۔ ان idiomatic patterns کو جاننا آپ کو صحیح، موثر 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** goroutines کی ایک مقررہ تعداد چلاتا ہے جو ایک مشترکہ jobs channel سے استعمال کر رہی ہوتی ہے — concurrency کو محدود کرتے ہوئے (مثال کے طور پر 10,000 DB connections نہ کھولیں؛ 10 workers استعمال کریں)۔ یہ وسائل کی استعمال کو کنٹرول کرنے کے لیے سب سے اہم 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 — 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** processing کے مراحل کو 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
}
```

## Cancellation with context (cross-cutting)

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

## یہ اہم کیوں ہے

یہ concurrency patterns حقیقی concurrent Go systems بنانے کے لیے عملی toolkit ہیں، خام goroutines اور channels کو بار بار آنے والے مسائل کے منطقی، صحیح حل میں تبدیل کرتے ہیں۔

**worker pool** خاص طور پر اہم ہے — یہ محدود وسائل (database connections، API rate limits، memory) کو محفوظ رکھنے کے لیے concurrency کو محدود کرتا ہے، لامحدود goroutines بنانے کی عام غلطی سے بچاتا ہے جو نظام کو مفلوج کر سکتے ہیں۔ **Fan-out/fan-in** کام کو متوازی بناتا ہے اور نتائج کو یکجا کرتا ہے؛ **pipelines** streaming ڈیٹا کی تبدیلی کو صاف طریقے سے ماڈل کرتے ہیں؛ **rate limiting** throughput کو کنٹرول کرتا ہے۔

**context-based cancellation** کے ساتھ مل کر (goroutine leaks سے بچنے کے لیے)، یہ patterns وہ ہیں جن سے production Go services concurrency کو محفوظ اور موثر انداز میں ہینڈل کرتے ہیں۔

انہیں سمجھنا — اور خاص طور پر یہ جاننا کہ worker pools کے ساتھ concurrency کو محدود کریں بجائے لامحدود goroutines چلانے کے — سینیئر Go competence کی علامت ہے اور ایک متکرر advanced interview موضوع ہے، کیونکہ بے وقوفانہ concurrency (لامحدود goroutines، leaks، races) production failures کا ایک عام ذریعہ ہے۔