Quels sont les patterns courants de concurrence en Go ?

Question

IT Interview Practice · 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.

Pool de workers — concurrence bornée

Fan-out / fan-in

Pipeline — étapes connectées par des channels

Rate limiting

Cancellation avec context (cross-cutting)

Pourquoi c'est important

Questions connexes