La plus grande erreur des débutants en Go est de confondre une concurrence facile avec une concurrence gratuite.
Les goroutines sont légères, ce qui est excellent. Elles demandent néanmoins un certain travail, et elles consomment toujours du CPU, de la mémoire, des sockets et des descripteurs de fichiers indirectement par le biais des tâches qu'elles exécutent.
Le Problème de la Propagation Illimitée
Cela fonctionne bien à petite échelle :
for _, file := range files {
go downloadAndParse(file)
}
Cela devient dangereux lorsque la taille de la boucle reflète une entrée externe ou un arriéré important.
L'échec habituel n'est pas "trop de goroutines" en tant que nombre abstrait. Il s'agit d'une épuisement en aval :
- trop de connexions ouvertes
- trop de pression I/O
- trop de mémoire en transit
Pourquoi les Pools de Travailleurs Aident
Les pools de travailleurs créent une contre-pression en limitant la quantité de travail qui peut être exécutée de manière concurrente :
func worker(jobs <-chan string, results chan<- error) {
for file := range jobs {
results <- downloadAndParse(file)
}
}
L'important est le contrôle, pas le style.
Vous décidez combien de travail le système doit admettre à la fois, en fonction du véritable goulet d'étranglement.
Les Canaux Concernent la Coordination
Les canaux sont utiles parce qu'ils rendent le passage explicite :
- qui produit du travail
- qui le consomme
- où le système doit se bloquer
C'est souvent plus clair et plus sûr que de laisser la concurrence se répandre implicitement.
La Meilleure Règle
Ne demandez pas "cela peut-il être concurrent ?"
Demandez :
- quel est le goulet d'étranglement ?
- combien de concurrence peut-il tolérer ?
- où la contre-pression doit-elle se produire ?
C'est ainsi que la concurrence en Go devient de l'ingénierie au lieu d'optimisme.
Lectures Complémentaires