Go లో సాధారణ సమకాలీకరణ నమూనాలు ఏవి?

Question

Accepted Answer

Go యొక్క goroutines మరియు channels సుస్థిర **సమకాలీకరణ నమూనాలను** ప్రారంభించాయి, ఇవి సాధారణ సమస్యలను పరిష్కరిస్తాయి — పని పంపిణీ, fanning out/in, pipelines, మరియు rate limiting. ఈ idiiomatic నమూనాలను తెలుసుకోవడం ద్వారా మీరు సరైన, సమర్థవంతమైన సమకాలీకరణ వ్యవస్థలను నిర్మించవచ్చు.

## Worker pool — సీమితమైన సమకాలీకరణ

```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 నుండి వినియోగం చేయడానికి నడుపుతుంది — సమకాలీకరణను సీమితం చేస్తుంది (ఉదా 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 ద్వారా సంযోగం చేయబడిన దశలు

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

## ఇది ఎందుకు ముఖ్యమైనది

ఈ సమకాలీకరణ నమూనాలు నిజమైన సమకాలీకరణ Go వ్యవస్థలను నిర్మించడానికి ఆచరణాత్మక సాధనదిక, ముడి goroutines మరియు channels లను పునరావృత సమస్యలకు నిర్మిత, సరైన పరిష్కారాలుగా మార్చుకోవడం.

**worker pool** ప్రత్యేకంగా ముఖ్యమైనది — ఇది సීమితమైన వనరులను రక్షించడానికి సమకాలీకరణను సీమితం చేస్తుంది (database connections, API rate limits, memory), సీమాహీన goroutines ను ఉత్పన్నం చేసే సాధారణ పొరపాటును నిరోధించి సిస్టమ్‌ను క్షీణింపజేస్తుంది. **Fan-out/fan-in** పనిని సమాంతరంగా చేస్తుంది మరియు ఫలితాలను విలీనం చేస్తుంది; **pipelines** డేటా రూపాంతర స్ట్రీమింగ్‌ను స్పష్టంగా రూపొందించుకోవడం; **rate limiting** throughput లను నియంత్రిస్తుంది.

**context-based cancellation** (goroutine చాటిని నివారించడానికి) కలిపి, ఈ నమూనాలు ఉత్పత్తి Go సేవలు సమకాలీకరణను సురక్షితంగా మరియు సమర్థవంతంగా నిర్వహిస్తాయి.

ఈ నమూనాలను అర్థం చేసుకోవడం — మరియు ప్రత్యేకంగా సీమితమైన goroutines ను ఉపయోగించకుండా worker pools తో సమకాలీకరణను సీమితం చేయాలని తెలుసుకోవడం — సిన్యర్ Go సామర్థ్యం యొక్క లక్షణం మరియు తరచుగా ఆధునిక ఇంటర్‌వ్యూ విషయం, ఎందుకంటే నిష్క్రియ సమకాలీకరణ (సీమాహీన goroutines, leaks, races) ఉత్పత్తి వైఫల్యాల సాధారణ మూలం.