Kaj so pogosti vzorci za sočasnost v jeziku Go?

Question

Accepted Answer

Goovi goroutini in kanali omogočajo nabor dobro uveljavljenih **vzorcev za sočasnost**, ki rešavajo pogoste težave — razdeljevanje dela, razpršitev/zbiranje, cevovodi in omejitev hitrosti. Poznavanje teh idiomatskih vzorcev vam omogoča gradnjo pravilnih in učinkovitih sočasnih sistemov.

## Bazen delavcev — omejena sočasnost

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

**Bazen delavcev** zažene fiksno število gorutinov, ki porabljajo iz deljene kanale za delo — omejevanje sočasnosti (npr. ne odprite 10.000 povezav v bazo podatkov; uporabite 10 delavcev). To je najpomembnejši vzorec za nadzor porabe virov.

## Razpršitev / zbiranje

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

## Cevovod — stopnje povezane s kanali

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

**Cevovod** povezuje stopnje obdelave prek kanalov — podatki tečejo skozi, vsaka stopnja jih pretvari sočasno.

## Omejitev hitrosti

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

## Preklic s kontekstom (presečni vidik)

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

## Zakaj je to pomembno

Ti vzorci za sočasnost so praktični nabor orodij za gradnjo resničnih sočasnih Go sistemov, ki surove goroutine in kanale spremenijo v strukturirane, pravilne rešitve ponavljajočih se težav.

**Bazen delavcev** je posebej pomemben — omejuje sočasnost za zaščito omejenih virov (povezave v bazo podatkov, omejitve stopnje API-ja, pomnilnik), preprečevanjem pogoste napake neomejenih gorutinov, ki izčrpajo sistem. **Razpršitev/zbiranje** paralelizira delo in združi rezultate; **cevovodi** čisto modelirajo transformacije tokovnih podatkov; **omejitev hitrosti** nadzira prepustnost.

V kombinaciji s **preklici na osnovi konteksta** (za izogibanje puščanju gorutinov) so ti vzorci način, kako proizvodne Go storitve varno in učinkovito obravnavajo sočasnost.

Razumevanje njih — in še posebej vedenje, da sočasnost omejite z bazeni delavcev namesto zagona neomejenih gorutinov — je znamenje starejše Go kompetence in pogosta napredna tema v intervjujih, saj je naivna sočasnost (neomejeni goroutini, puščanja, tekmovanja) pogost vir proizvodnih napak.