X'inhuma l-mudelli komuni ta' konkorrenza f'Go?

Question

Accepted Answer

Goroutines u channels ta' Go jippermettu sett ta' **mudelli ta' konkorrenza** stabbilit sew li jsolvu problemi komuni — distribuzzjoni tax-xogħol, fan-out/fan-in, pipelines, u rate limiting. Billi taf dawn il-mudelli idiomatiċi, tista' tibni sistemi konkorrenti tat-tajjeb u effizzjenti.

## Għaliex Huwa Importanti

```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** ijokkilja numru fissu ta' goroutines li jikkonsumu minn channel ta' jobs miftiehem — il-konkorrenza hija limitata (pereż, tħarrex milli tiftaħ 10,000 konnessjonijiet DB; uża 10 workers). Dan huwa l-aktar mudell importanti għall-kontroll tal-użu tal-riżorsi.

## 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 — stadji konnessi b'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** tgħaqqad istadji ta' pproċessar permezz ta' channels — id-data titgħaddi, kull stadju jittrasformaha b'mod konkorrenti.

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

## Kanċellazzjoni b'context (transversali)

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

## Għaliex Huwa Importanti

Dawn il-mudelli ta' konkorrenza huma l-toolkit prattika għall-bini ta' sistemi Go konkorrenti reali, li jittrasformaw goroutines u channels raw f'soluzzjonijiet strutturati u korretti għal problemi li jirrepetew.

**Worker pool** huwa partikolarment importanti — jillimita l-konkorrenza biex jipproteġi riżorsi limitati (konnessjonijiet bażi ta' dejta, limiti ta' rata API, memoria), ipparrevent l-iżball komuni ta' tluq ta' goroutines illimitati li jexhawstaw is-sistema. **Fan-out/fan-in** jipparallelize l-xogħol u jgħaqqad ir-riżultati; **pipelines** jmudellaw it-trasformazzjonijiet tad-data streaming b'mod ċar; **rate limiting** jikkontrolla l-throughput.

Ikkombinati ma' **kanċellazzjoni bbażata fuq context** (biex nevitaw tnixxija ta' goroutines), dawn il-mudelli huma kif is-servizzi Go tal-produzzjoni jittrattaw il-konkorrenza b'mod sigur u effiċjenti.

Fhimhom — u speċjalment ta' taf biex jillimita l-konkorrenza b'worker pools minflok tluq ta' goroutines illimitati — huwa sinn ta' kompetenza Go senior u suġġett ta' intervju avvanzat ta' spiss, billi l-konkorrenza ingenwwa (goroutines illimitati, tnixxija, races) hija sors komuni ta' fallimenti tal-produzzjoni.