Ni mifumo gani ya kawaida ya concurrency katika Go?

Question

Accepted Answer

Goroutines na channels za Go zinawezesha seti ya **mifumo ya concurrency** iliyothibitishwa vizuri ambayo hutatua matatizo ya kawaida — kugawanya kazi, fan-out/in, pipelines, na rate limiting. Kujua mifumo hii ya kiidiomatiki kunakuwezesha kujenga mifumo ya concurrent iliyo sahihi na yenye ufanisi.

## Worker pool — concurrency yenye mipaka

```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** huendesha idadi maalum ya goroutines zinazotumia kutoka kwa jobs channel inayoshirikiwa — ikiweka mipaka kwa concurrency (mfano, usifungue muunganisho 10,000 wa DB; tumia workers 10). Huu ni mfumo muhimu zaidi kwa kudhibiti matumizi ya rasilimali.

## 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 — hatua zilizounganishwa na 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) }
```

**Pipeline** huunganisha hatua za usindikaji kupitia channels — data hupita kwa mtiririko, kila hatua ikiibadilisha kwa concurrency.

## 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 kwa context (cross-cutting)

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

## Kwa nini ni muhimu

Mifumo hii ya concurrency ni zana ya vitendo ya kujenga mifumo halisi ya concurrent ya Go, ikigeuza goroutines na channels mbichi kuwa suluhisho zilizopangwa na sahihi kwa matatizo yanayojirudia.

**Worker pool** ni muhimu hasa — inaweka mipaka kwa concurrency ili kulinda rasilimali zenye ukomo (muunganisho wa hifadhidata, rate limits za API, kumbukumbu), ikizuia kosa la kawaida la kuanzisha goroutines zisizo na mipaka ambazo huishia kumaliza rasilimali za mfumo. **Fan-out/fan-in** huendesha kazi kwa pamoja na kuunganisha matokeo; **pipelines** huiga mabadiliko ya data ya mtiririko kwa usafi; **rate limiting** hudhibiti throughput.

Ikiunganishwa na **cancellation inayotegemea context** (kuepuka goroutine leaks), mifumo hii ndio jinsi huduma za Go za uzalishaji zinavyoshughulikia concurrency kwa usalama na ufanisi.

Kuielewa — na hasa kujua kuweka mipaka kwa concurrency kwa worker pools badala ya kuanzisha goroutines zisizo na ukomo — ni alama ya umahiri wa kiwango cha senior wa Go na ni mada ya mara kwa mara ya juu katika mahojiano, kwa kuwa concurrency ya kijinga (goroutines zisizo na mipaka, leaks, races) ni chanzo cha kawaida cha kushindwa kwa uzalishaji.