பொதுவான Go concurrency patterns என்ன?

Question

Accepted Answer

Go-வின் goroutines மற்றும் channels ஆனவை, பொதுவான பிரச்சினைகளைத் தீர்க்கும் நன்கு நிறுவப்பட்ட **concurrency patterns** தொகுப்பை சாத்தியமாக்குகின்றன — வேலையைப் பகிர்தல், fan-out/in, pipelines, மற்றும் rate limiting. இந்த idiomatic patterns-ஐ அறிந்திருப்பது, சரியான, திறமையான concurrent அமைப்புகளை உருவாக்க உதவுகிறது.

## 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** ஆனது, ஒரு பகிரப்பட்ட jobs channel-இலிருந்து உட்கொள்ளும் நிலையான எண்ணிக்கையிலான goroutines-ஐ இயக்குகிறது — 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 மூலம் இணைக்கப்பட்ட 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 மூலம் processing stages-ஐ இணைக்கிறது — data stream ஆக பாய்கிறது, ஒவ்வொரு stage-ம் அதை concurrent ஆக மாற்றுகிறது.

## 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 patterns ஆனவை, உண்மையான concurrent Go அமைப்புகளை உருவாக்குவதற்கான நடைமுறை கருவித் தொகுப்பாகும்; raw goroutines மற்றும் channels-ஐ, மீண்டும் வரும் பிரச்சினைகளுக்கான கட்டமைக்கப்பட்ட, சரியான தீர்வுகளாக மாற்றுகின்றன.

**Worker pool** குறிப்பாக முக்கியமானது — வரம்புக்குட்பட்ட வளங்களை (database connections, API rate limits, memory) பாதுகாக்க concurrency-ஐ வரம்பிடுகிறது; அமைப்பை வற்றச்செய்யும் வரம்பற்ற goroutines-ஐ உருவாக்கும் பொதுவான தவறைத் தடுக்கிறது. **Fan-out/fan-in** வேலையை parallelize செய்து முடிவுகளை merge செய்கிறது; **pipelines** streaming data மாற்றங்களை சுத்தமாக மாதிரியாக்குகின்றன; **rate limiting** throughput-ஐ கட்டுப்படுத்துகிறது.

**Context அடிப்படையிலான cancellation**-உடன் (goroutine leaks-ஐ தவிர்க்க) இணைந்து, production Go services ஆனவை concurrency-ஐ பாதுகாப்பாகவும் திறமையாகவும் கையாள்வது இந்த patterns மூலமாகவே.

இவற்றைப் புரிந்துகொள்வது — குறிப்பாக வரம்பற்ற goroutines-ஐ துவக்குவதற்குப் பதிலாக worker pools மூலம் concurrency-ஐ வரம்பிட வேண்டும் என்பதை அறிவது — senior Go திறமையின் அடையாளம் மற்றும் ஒரு அடிக்கடி வரும் மேம்பட்ட interview தலைப்பு; ஏனெனில் naive concurrency (வரம்பற்ற goroutines, leaks, races) ஆனது production தோல்விகளுக்கு ஒரு பொதுவான மூலகாரணமாகும்.