Cilat janë modelet e zakonshme të concurrency në Go?

Question

Accepted Answer

Goroutinat dhe kanalat e Go-it mundësojnë një seri modelesh **concurrency** të mirë të vendosura që zgjidhin probleme të zakonshme — shpërndarjen e punës, fan-out/fan-in, pipelines, dhe rate limiting. Njohja e këtyre modeleve idiomatike ju lejon të ndërtoni sisteme concurrency të saktë dhe efikase.

## Worker pool — concurrency i kufizuar

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

Një **worker pool** përpunon një numër të fiksuar të goroutinave që konsumojnë nga një kanal pune i përbashkët — duke kufizuar concurrency-n (p.sh. mos hapni 10,000 lidhje DB; përdorni 10 workers). Ky është modeli më i rëndësishëm për kontrollimin e përdorimit të burimeve.

## 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 — hapat e lidhur nga kanalat

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

Një **pipeline** lidh hapat e përpunimit përmes kanaleve — të dhënat rrjedhin përmes, çdo hap e transformon atë përkatësisht.

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

## Anulim me context (cross-cutting)

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

## Pse ka rëndësi

Këto modele concurrency janë kutia praktike e veglave për ndërtimin e sistemeve reale concurrency në Go, duke kthyer goroutinat dhe kanalat e papërpunuar në zgjidhje të strukturuara dhe të sakta për probleme të përsëritura.

Një **worker pool** është veçanërisht i rëndësishëm — ai kufizon concurrency-n për të mbrojtur burimet e kufizuara (lidhjet e bazës së të dhënave, limitet e API, memorien), duke parandaluar gabimin e zakonshëm të krijimit të goroutinave pa limite që shterpojnë sistemin. **Fan-out/fan-in** paralelizojnë punën dhe bashkojnë rezultatet; **pipelines** modelojnë transformimet e të dhënave me rrjedh në mënyrë të pastër; **rate limiting** kontrollon fluiditetin.

Në kombinim me **anulimin e bazuar në context** (për të shmangur rrjedhjet e goroutinave), këto modele janë mënyra sesi shërbimet Go në prodhim trajtojnë concurrency-n në mënyrë të sigurë dhe efikase.

Përmendja e tyre — dhe veçanërisht njohja për të kufizuar concurrency-n me worker pools në vend të nisjes së goroutinave të pakufizuara — është simbol i kompetencës Go të nivelit të lartë dhe një temë interviste e përparuar shpesh, pasi concurrency naive (goroutina pa limite, rrjedhje, gara) është burim i zakonshëm i dështimeve në prodhim.