La concurrence n'est pas qu'une fonctionnalité de Go ; c'est le fondement de sa philosophie de conception. Contrairement aux langages qui reposent sur les threads et les verrous, ce qui conduit souvent à des conditions de course complexes et à une surcharge, Go introduit les goroutines et les channels pour gérer les tâches concurrentes avec élégance et sécurité. Pour les développeurs intermédiaires à avancés, maîtriser ces patterns est essentiel pour construire des services backend performants et évolutifs. Cet article explore les concepts de base, les patterns pratiques et les pièges courants de la concurrence en Go.
Comprendre les Goroutines
Une goroutine est un fil d'exécution léger géré par l'exécution de Go (runtime) plutôt que par le système d'exploitation. Cette distinction est cruciale. Alors que les threads du système d'exploitation consomment une quantité significative de mémoire et nécessitent des changements de contexte, les goroutines démarrent avec seulement quelques kilo-octets d'espace de pile, qui grandit et rétrécit dynamiquement. Vous pouvez lancer des milliers, voire des millions, de goroutines sur une seule machine sans épuiser les ressources système.
Créer une goroutine est aussi simple que de préfixer un appel de fonction avec le mot-clé go. Cependant, il est important de se rappeler que la goroutine principale (qui exécute main()) n'attend pas que les autres goroutines terminent par défaut. Si la fonction principale se termine, toutes les autres goroutines sont immédiatement terminées, quel que soit leur état.
Les Channels : Communication sans mémoire partagée
L'un des mantras les plus célèbres de Go est : « Ne communiquez pas en partageant la mémoire ; partagez plutôt la mémoire en communiquant. » Cela est réalisé grâce aux channels. Les channels agissent comme des tuyaux qui connectent les goroutines concurrentes, leur permettant d'envoyer et de recevoir des valeurs de types spécifiques. Ils offrent un moyen sûr de synchroniser l'exécution et d'éviter les conditions de course sur les données.
Les channels peuvent être tamponnés (buffered) ou non tamponnés. Un channel non tamponné bloque l'expéditeur jusqu'à ce que le récepteur soit prêt, assurant une synchronisation stricte. Un channel tamponné permet à l'expéditeur de continuer tant que le tampon a de l'espace, ce qui peut améliorer le débit mais nécessite une gestion attentive pour éviter les blocages (deadlocks) ou les fuites de ressources.
Pattern pratique : Pools de travailleurs
L'un des patterns de concurrence les plus courants et utiles en Go est le pool de travailleurs (worker pool). Ce pattern limite le nombre de goroutines concurrentes, ce qui est vital lors du traitement de tâches intensives en ressources comme les requêtes de base de données ou les appels d'API externes. Sans limiter la concurrence, vous risquez de submerger votre base de données avec trop de connexions.
Imaginez un scénario où vous devez traiter une grande liste de tâches. Vous pouvez créer un nombre fixe de travailleurs qui extraient les tâches d'un channel partagé.
package main
import (
"fmt"
"sync"
)
func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
defer wg.Done()
for j := range jobs {
fmt.Printf("Worker %d started job %d\n", id, j)
// Simuler du travail
results <- j * 2
}
}
func main() {
const numJobs = 5
const numWorkers = 3
jobs := make(chan int, numJobs)
results := make(chan int, numJobs)
var wg sync.WaitGroup
// Démarrer les travailleurs
for w := 1; w <= numWorkers; w++ {
wg.Add(1)
go worker(w, jobs, results, &wg)
}
// Envoyer les tâches
for j := 1; j <= numJobs; j++ {
jobs <- j
}
close(jobs)
// Fermer les résultats une fois tous les travailleurs terminés
go func() {
wg.Wait()
close(results)
}()
// Collecter les résultats
for r := range results {
fmt.Println("Received result:", r)
}
}Dans cet exemple, nous utilisons un sync.WaitGroup pour attendre que tous les travailleurs aient terminé avant de fermer le channel des résultats. Cela garantit qu'aucune donnée n'est perdue et que le programme se termine proprement.
Éviter les blocages et les fuites
Malgré sa simplicité, la concurrence en Go peut être délicate. Un piège courant est le blocage (deadlock), qui se produit lorsqu'une goroutine attend une opération sur un channel qui ne peut jamais se terminer car aucune autre goroutine n'envoie ou ne reçoit. Un autre problème est la fuite de goroutines, où les goroutines continuent de s'exécuter indéfiniment, consommant de la mémoire.
Pour atténuer ces risques, envisagez toujours d'utiliser le package context. Les contextes vous permettent de propager des signaux d'annulation et des délais d'expiration à travers les goroutines, garantissant que les tâches de longue durée peuvent être arrêtées gracefully si elles prennent trop de temps ou si la requête parente est annulée.
Conclusion
L'approche de Go en matière de concurrence offre une boîte à outils puissante pour construire des logiciels efficaces. En tirant parti des goroutines pour la concurrence légère et des channels pour la communication sûre, les développeurs peuvent écrire du code à la fois performant et lisible. Cependant, le succès exige de la discipline. Gérez toujours les ressources avec soin, utilisez les primitives de synchronisation comme sync.WaitGroup et sync.Mutex de manière appropriée, et adoptez l'annulation de contexte pour construire des systèmes résilients. Avec la pratique, ces patterns deviennent une seconde nature, vous permettant d'exploiter toute la puissance des capacités concurrentes de Go.