Cad iad na patrúin coiteanna comhshrianta Go?

Question

Accepted Answer

Cumasaíonn goroutines agus channels Go sraith patrúin comhshrianta **well-established** a réitíonn fadhbanna coiteanna — dáileadh oibre, fanning out/in, pipelines, agus rate limiting. Trí na patrúin idiomatic seo a bheith ar eolas agat, is féidir leat córais chomhshrianta cearta agus éifeachtach a thógáil.

## Linn oibrí — comhshrianta faoi theorainn

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

Rithionn **worker pool** líon socraithe goroutines ag ithe ó chainéal poist roinnte — ag socrú na comhshrianta (e.g. ná hoscail 10,000 naisc DB; úsáid 10 oibrí). Seo an patrún is tábhachtaí maidir le húsáid acmhainní a rialú.

## 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 — stáideanna ceangailte le 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) }
```

Ceanglaíonn **pipeline** stáideanna próiseála trí channels — sreabhadh sonraí tríd, gach staid ag claochlú go comhshrianta.

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

## Cealúchán le context (trasndomhain)

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

## Cén fáth a bhíonn tábhacht air

Is iad na patrúin comhshrianta seo an t-uirlis phraiticiúil do bhogearraí comhshrianta fíor Go a thógáil, ag tiontú goroutines agus channels amh ina thuarascálacha struchtúrtha agus cearta ar fhadhbanna a bhíonn ann arís agus arís eile.

Tá an **worker pool** go háirithe tábhachtach — cuireann sé teorainn ar an gcomhshrianta chun acmhainní teoranta a dhíon (naisc bhunachar sonraí, teorainneacha ráta API, cuimhne), ag cosc na botúin coiteanna maidir le goroutines neamhtheoranta a bhogadh ar leataobh a dhéanann an córas tuirseach. Déanann **fan-out/fan-in** oibre a chur i bhfeidhm go comhthreomhar agus torthaí a chomhcheangal; **pipelines** molann claochlaithe sonraí sreabhach go geal; **rate limiting** smachtaíonn sreabhadh.

A bheith in éineacht le **context-based cancellation** (chun leakanna goroutine a sheachaint), is iad na patrúin seo an chaoi a bhíonn seirbhísí Go táirgthe ag déileáil le comhshrianta go sábháilte agus go éifeachtach.

A bheith ar thuiscint agat orthu — agus go háirithe a bheith ar eolas go gcuireann pool oibrí teorainn ar an gcomhshrianta seachas goroutines neamhtheoranta a bhogadh — is marc sin ar inniúlacht Go sinsearach agus topaic agallamh ardleibhéal go rialta, ós rud é go bhíonn comhshrianta naïve (goroutines gan teorainn, leakanna, rásaí) ina fhoinse coiteann d'adhbharchuideachta táirgthe.