Melyek a Go párhuzamosságának gyakori mintái?

Question

Accepted Answer

A Go goroutine-jai és channel-jei jól bevált **párhuzamosságyi mintákat** tesznek lehetővé, amelyek megoldják a gyakori problémákat — munka elosztása, fan-out/in, pipeline-ok és sebességhatárlimitálás. Ezen idiómatikus minták ismerete lehetővé teszi korrektek és hatékony párhuzamos rendszerek építését.

## Worker pool — korlátozott párhuzamosság

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

A **worker pool** egy rögzített számú goroutine-t futtat, amelyek egy megosztott jobs channel-ből fogyasztanak — korlátozva a párhuzamosságot (például ne nyissunk meg 10 000 adatbázis-kapcsolatot; használjunk 10 worker-t). Ez a legfontosabb minta az erőforrás-felhasználás szabályozásához.

## 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 — csatornákkal összekötött szakaszok

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

A **pipeline** feldolgozási szakaszokat lánc össze channel-eken keresztül — az adat átfolyik, és minden szakasz egyidejűleg alakítja azt.

## Sebességhatárlimitálás

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

## Törlés context-tel (keresztmetszeti)

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

## Miért fontos

Ezek a párhuzamosságyi minták a gyakorlati eszköztárját képezik a valós párhuzamos Go rendszerek építésének, a nyers goroutine-okat és channel-eket strukturált, helyes megoldásokká alakítva az ismétlődő problémákra.

A **worker pool** különösen fontos — korlátozza a párhuzamosságot a korlátozott erőforrások (adatbázis-kapcsolatok, API-rate limit-ek, memória) védelméhez, megakadályozva a gyakori hibát az korlátlan goroutine-ok indításáról, amelyek kimerítik a rendszert. A **fan-out/fan-in** párhuzamosítja a munkát és egyesíti az eredményeket; a **pipeline-ok** tisztán modellezik az adatáramlás átalakítási lépéseit; a **sebességhatárlimitálás** szabályozza az áteresztőképességet.

A **context-alapú törlés** kombinálva (a goroutine-szivárgás elkerüléséhez), ezek a minták arra valók, hogyan kezelik a termelési Go szolgáltatások a párhuzamosságot biztonságosan és hatékonyan.

Azok megértése — és különösen tudni, hogy a worker pool-okkal kell korlátozni a párhuzamosságot, ahelyett hogy korlátlan goroutine-okat indítanánk — a senior Go kompetencia jellemzője, és egy gyakori haladó interjú-téma, mivel az ún. naív párhuzamosság (korlátlan goroutine-ok, szivárgások, versengések) egy gyakori termelési hibák forrása.