Quels sont les patterns courants de concurrence en Go ?

Question

Accepted Answer

Les goroutines et les channels de Go permettent un ensemble de **patterns de concurrence** bien établis qui résolvent des problèmes courants — distribuer le travail, fan-out/fan-in, pipelines et rate limiting. Connaître ces patterns idiomatiques vous permet de construire des systèmes concurrents corrects et efficaces.

## Pool de workers — concurrence bornée

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

Un **worker pool** exécute un nombre fixe de goroutines consommant depuis un channel partagé de jobs — en bornant la concurrence (par ex. ne pas ouvrir 10 000 connexions à la base de données ; utiliser 10 workers). C'est le pattern le plus important pour contrôler l'utilisation des ressources.

## 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 — étapes connectées par des 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) }
```

Un **pipeline** chaîne les étapes de traitement via des channels — les données transitent, chaque étape les transformant concurrence.

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

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

## Pourquoi c'est important

Ces patterns de concurrence forment la boîte à outils pratique pour construire de vrais systèmes concurrents en Go, transformant les goroutines et channels bruts en solutions structurées et correctes pour les problèmes récurrents.

Le **worker pool** est particulièrement important — il borne la concurrence pour protéger les ressources limitées (connexions à la base de données, limites de débit d'API, mémoire), en évitant l'erreur courante de lancer un nombre illimité de goroutines qui épuisent le système. **Fan-out/fan-in** parallélise le travail et fusionne les résultats ; les **pipelines** modélisent proprement les transformations de données en streaming ; le **rate limiting** contrôle le débit.

Combinés avec la **cancellation basée sur context** (pour éviter les fuites de goroutines), ces patterns sont la façon dont les services Go de production gèrent la concurrence de manière sûre et efficace.

Les comprendre — et surtout savoir borner la concurrence avec des worker pools plutôt que de lancer un nombre illimité de goroutines — est une marque de compétence Go senior et un sujet d'entretien avancé fréquent, car la concurrence naïve (goroutines illimitées, fuites, courses critiques) est une source courante d'échecs en production.