errgroup pour la gestion concurrente des erreurs
Mettre en pratique golang.org/x/sync/errgroup
errgroup pour la gestion concurrente des erreurs est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.
Problème des goroutines et des erreurs
Lancer des goroutines avec go func() ignore les valeurs renvoyées, y compris les erreurs. Des mécanismes supplémentaires (canaux, WaitGroup) sont nécessaires pour les collecter. errgroup simplifie cette tâche.
golang.org/x/sync/errgroup
errgroup.Group exécute des goroutines et collecte les erreurs. Wait() bloque jusqu'à la fin de toutes les goroutines et renvoie la première erreur non nulle.
var g errgroup.Group
g.Go(func() error { return fetchUsers() })
g.Go(func() error { return fetchOrders() })
if err := g.Wait(); err != nil {
log.Fatal(err)
}errgroup.WithContext
WithContext renvoie un groupe et un contexte dérivé. Le contexte est annulé lorsqu'une première goroutine renvoie une erreur, ce qui arrête le travail restant.
g, ctx := errgroup.WithContext(context.Background())
g.Go(func() error { return doWork(ctx) })
g.Go(func() error { return doOtherWork(ctx) })
err := g.Wait()Collecte des résultats et des erreurs
errgroup ne collecte pas les résultats, uniquement les erreurs. Capturez les résultats dans des tranches préallouées auxquelles vous accédez par index afin d'éviter la synchronisation :
results := make([]Result, len(items))
for i, item := range items {
i, item := i, item
g.Go(func() error {
r, err := process(ctx, item)
if err != nil { return err }
results[i] = r
return nil
})
}
if err := g.Wait(); err != nil { return err }g.SetLimit (Go 1.20+)
g.SetLimit(n) plafonne le nombre de goroutines exécutées simultanément — cela agit comme un sémaphore intégré sans canal distinct.
g.SetLimit(10) // at most 10 goroutines at once
for _, item := range items {
g.Go(func() error { return process(item) })
}g.TryGo
g.TryGo(f) démarre la goroutine uniquement si la limite (définie par SetLimit) le permet. Renvoie false si elle n'est pas démarrée.
Seule la première erreur est renvoyée
errgroup renvoie uniquement la première erreur. Si vous avez besoin de toutes les erreurs, collectez-les dans une tranche protégée par un mutex au sein de chaque goroutine.
var mu sync.Mutex
var errs []error
g.Go(func() error {
if err := doWork(); err != nil {
mu.Lock(); errs = append(errs, err); mu.Unlock()
}
return nil
})Différence avec sync.WaitGroup
WaitGroup suit la fin des opérations ; errgroup suit leur fin ET collecte les erreurs. Préférez errgroup lorsqu'un échec d'une goroutine doit être signalé.
Propagation de l'annulation du contexte
Lorsque vous utilisez errgroup.WithContext, l'annulation du contexte dérivé signale à toutes les autres goroutines de s'arrêter — selon une sémantique similaire à l'annulation à la première erreur.
Tester le code errgroup
Dans les tests, injectez un contexte avec WithTimeout afin de vous assurer que le groupe ne s'exécute pas indéfiniment si une goroutine reste bloquée.
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
g, ctx := errgroup.WithContext(ctx)Alternative au sémaphore
Avant SetLimit (Go < 1.20), utilisez un canal avec tampon comme sémaphore au sein de goroutines individuelles pour obtenir le même effet.
Vérification rapide
Que renvoie errgroup.WithContext que ne renvoie pas un simple errgroup.Group ?
Récapitulatif : errgroup
Points clés :
- g.Go(func() error) — lancer une goroutine et collecter la première erreur
- g.Wait() — bloque jusqu'à la fin de toutes les goroutines ; renvoie la première erreur
- WithContext — contexte annulé à la première erreur
- g.SetLimit(n) — plafonner le nombre de goroutines simultanées (Go 1.20+)
Questions Fréquemment Posées
La leçon « errgroup pour la gestion concurrente des erreurs » est-elle gratuite ?
Oui — le texte complet de « errgroup pour la gestion concurrente des erreurs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « errgroup pour la gestion concurrente des erreurs » ?
Mettre en pratique golang.org/x/sync/errgroup Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Go Academy ?
Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « errgroup pour la gestion concurrente des erreurs » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?
Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Modèles de pipeline et d’étapes
- errgroup pour la gestion concurrente des erreurs
- Modèle du sémaphore
- Détection des fuites et annulation