Go এর সাধারণ concurrency প্যাটার্নগুলি কী কী?

Question

Accepted Answer

Go এর goroutines এবং channels একটি সুপ্রতিষ্ঠিত **concurrency প্যাটার্ন** এর সেট সক্ষম করে যা সাধারণ সমস্যাগুলির সমাধান করে — কাজ বিতরণ, fan-out/in, pipelines, এবং rate limiting। এই idiomatic প্যাটার্নগুলি জানা আপনাকে সঠিক, দক্ষ concurrent সিস্টেম তৈরি করতে দেয়।

## Worker pool — সীমাবদ্ধ 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** একটি নির্দিষ্ট সংখ্যক goroutine চালায় যা একটি ভাগ করা jobs channel থেকে ভোগ করে — concurrency কে সীমাবদ্ধ করে (যেমন 10,000 DB সংযোগ খোলবেন না; 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** channels এর মাধ্যমে প্রক্রিয়াকরণ stages কে সংযুক্ত করে — ডেটা প্রবাহিত হয়, প্রতিটি stage এটিকে concurrently রূপান্তরিত করে।

## 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 সিস্টেম তৈরির জন্য ব্যবহারিক টুলকিট, যা raw goroutines এবং channels কে পুনরাবৃত্ত সমস্যাগুলির সংগঠিত, সঠিক সমাধানে রূপান্তরিত করে।

**worker pool** বিশেষভাবে গুরুত্বপূর্ণ — এটি সীমিত সম্পদ রক্ষা করার জন্য concurrency কে সীমাবদ্ধ করে (ডাটাবেস সংযোগ, API rate limits, মেমোরি), সীমাহীন goroutines স্পন্দন করার সাধারণ ভুল প্রতিরোধ করে যা সিস্টেমকে নিঃশেষ করে। **Fan-out/fan-in** কাজকে সমান্তরাল করে এবং ফলাফল মার্জ করে; **pipelines** স্ট্রিমিং ডেটা রূপান্তরণ পরিষ্কারভাবে মডেল করে; **rate limiting** throughput নিয়ন্ত্রণ করে।

**context-based cancellation** এর সাথে মিলিয়ে (goroutine leaks এড়াতে), এই প্যাটার্নগুলি হল production Go সেবাগুলি কীভাবে নিরাপদে এবং দক্ষতার সাথে concurrency পরিচালনা করে।

সেগুলি বোঝা — এবং বিশেষত সীমাহীন goroutines চালু করার পরিবর্তে worker pools এর সাথে concurrency কে সীমাবদ্ধ করতে জানা — senior Go competence এর একটি বৈশিষ্ট্য এবং একটি ঘন ঘন উন্নত সাক্ষাৎকার বিষয়, কারণ naive concurrency (সীমাহীন goroutines, leaks, races) উৎপাদন ব্যর্থতার একটি সাধারণ উত্স।