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

A **worker pool** goroutines ਦੀ ਇੱਕ ਸਥਿਰ ਸੰਖਿਆ ਚਲਾਉਂਦਾ ਹੈ ਜੋ ਸਾਂਝੇ jobs channel ਤੋਂ consume ਕਰਦੇ ਹਨ — concurrency ਨੂੰ ਸੀਮਿਤ ਕਰਦਾ ਹੈ (ਉਦਾ: 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 ਦੁਆਰਾ ਜੋੜਦਾ ਹੈ — ਡਾਟਾ ਵਹਿੰਦਾ ਹੈ, ਹਰੇਕ 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
}
```

## Cancellation with context (cross-cutting)

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

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

ਇਹ concurrency patterns ਅਸਲ concurrent Go systems ਬਣਾਉਣ ਲਈ ਵਿਹਾਰਕ ਟੂਲਕਿਟ ਹਨ, raw goroutines ਅਤੇ channels ਨੂੰ ਬਾਰ-ਬਾਰ ਆਉਣ ਵਾਲੀਆਂ ਸਮੱਸਿਆਵਾਂ ਦੇ structured, correct solutions ਵਿੱਚ ਬਦਲਦੇ ਹਨ।

The **worker pool** ਖਾਸ ਤੌਰ 'ਤੇ ਮਹੱਤਵਪੂਰਨ ਹੈ — ਇਹ concurrency ਨੂੰ ਸੀਮਿਤ resources (database connections, API rate limits, memory) ਦੀ ਰੱਖਿਆ ਕਰਨ ਲਈ ਬਾਂਧਦਾ ਹੈ, unbounded goroutines spawn ਕਰਨ ਦੀ ਆਮ ਗਲਤੀ ਨੂੰ ਰੋਕਦਾ ਹੈ ਜੋ system ਨੂੰ exhaust ਕਰਦੇ ਹਨ। **Fan-out/fan-in** ਕੰਮ ਨੂੰ parallelize ਕਰਦਾ ਹੈ ਅਤੇ results merge ਕਰਦਾ ਹੈ; **pipelines** streaming data transformations ਨੂੰ cleanly model ਕਰਦੇ ਹਨ; **rate limiting** throughput ਨੂੰ ਕੰਟਰੋਲ ਕਰਦਾ ਹੈ।

**context-based cancellation** ਦੇ ਨਾਲ ਮਿਲਾਕੇ (goroutine leaks ਤੋਂ ਬਚਣ ਲਈ), ਇਹ patterns ਉਹ ਹਨ ਜਿਵੇਂ production Go services concurrency ਨੂੰ safely ਅਤੇ efficiently ਹੈਂਡਲ ਕਰਦੇ ਹਨ।

ਇਨ੍ਹਾਂ ਨੂੰ ਸਮਝਣਾ — ਅਤੇ ਖਾਸ ਤੌਰ 'ਤੇ unlimited goroutines launch ਕਰਨ ਦੀ ਬਜਾਏ worker pools ਨਾਲ concurrency ਨੂੰ ਬਾਂਧਣਾ ਜਾਣਨਾ — senior Go competence ਦੀ ਨਿਸ਼ਾਨਦੇਹੀ ਹੈ ਅਤੇ ਇੱਕ ਅਕਸਰ advanced interview topic ਹੈ, ਕਿਉਂਕਿ naive concurrency (unbounded goroutines, leaks, races) production failures ਦਾ ਆਮ ਸਰੋਤ ਹੈ।