Go Academy · Leçon

sync.WaitGroup

Attendre un ensemble de goroutines

sync.WaitGroup 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.

Objectif

sync.WaitGroup attend la fin d’un ensemble de goroutines. La goroutine principale appelle Add pour définir le compteur, chaque goroutine appelle Done lorsqu’elle a terminé, et Wait bloque jusqu’à ce que le compteur atteigne zéro.

Utilisation de base

Appelez Add avant de lancer chaque goroutine ; appelez Done à la fin de chaque goroutine (via defer) ; appelez Wait après avoir lancé toutes les goroutines.

var wg sync.WaitGroup
for _, item := range items {
    wg.Add(1)
    go func(v Item) {
        defer wg.Done()
        process(v)
    }(item)
}
wg.Wait()

Add doit avoir lieu avant le démarrage de la goroutine

Appelez wg.Add(1) avant go func(), jamais à l’intérieur de la goroutine. Sinon, Wait pourrait retourner avant que la goroutine ne s’enregistre.

Erreur courante : capture de la variable de boucle

Transmettez la variable de boucle comme argument à la fonction de la goroutine, plutôt que par fermeture, afin d’éviter que toutes les goroutines partagent la même variable.

for _, v := range items {
    wg.Add(1)
    go func(item Item) { // correct: copy
        defer wg.Done()
        process(item)
    }(v)
}

Réutiliser un WaitGroup

Un WaitGroup peut être réutilisé après le retour de Wait, mais uniquement si tous les appels précédents à Done sont terminés. Ne le réutilisez pas alors que des appels à Done sont encore en cours.

WaitGroup avec résultats

WaitGroup ne collecte pas les résultats : combinez-le avec un canal ou une tranche (protégée par un mutex) pour recueillir la sortie des goroutines.

results := make([]Result, len(items))
for i, item := range items {
    wg.Add(1)
    go func(idx int, v Item) {
        defer wg.Done()
        results[idx] = process(v)
    }(i, item)
}
wg.Wait()

Add avec un compte groupé

Vous pouvez transmettre le nombre total à un seul appel à Add avant la boucle, ce qui est légèrement plus efficace qu’un appel à Add par goroutine.

wg.Add(len(items))
for _, item := range items {
    go func(v Item) { defer wg.Done(); process(v) }(item)
}

Ne copiez pas un WaitGroup

Comme Mutex, un WaitGroup ne doit pas être copié après sa première utilisation. Transmettez-le par pointeur ou intégrez-le dans une structure transmise par pointeur.

WaitGroup et errgroup

golang.org/x/sync/errgroup encapsule WaitGroup et ajoute la propagation des erreurs. Préférez errgroup lorsqu’un échec de goroutine doit arrêter les autres.

Combiner avec Context

Utilisez errgroup.WithContext pour obtenir à la fois la sémantique de WaitGroup et un Context qui est annulé à la première erreur, arrêtant proprement toutes les goroutines.

g, ctx := errgroup.WithContext(context.Background())
g.Go(func() error { return doWork(ctx) })
if err := g.Wait(); err != nil { log.Fatal(err) }

La valeur zéro est utilisable

La valeur zéro de sync.WaitGroup est prête à l’emploi : aucun constructeur n’est nécessaire. Déclarez-le simplement, puis appelez Add.

Vérification rapide

Que se passe-t-il si vous appelez wg.Add(1) à l’intérieur de la goroutine plutôt qu’avant son lancement ?

Récapitulatif : sync.WaitGroup

Points essentiels :

Add avant le lancement de la goroutine ; Done via defer à l’intérieur de la goroutine
Wait bloque jusqu’à ce que le compteur atteigne zéro
Ne copiez jamais le groupe ; n’appelez jamais Add à l’intérieur de la goroutine
Utilisez errgroup pour propager les erreurs

Questions Fréquemment Posées

La leçon « sync.WaitGroup » est-elle gratuite ?

Oui — le texte complet de « sync.WaitGroup » 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 « sync.WaitGroup » ?

Attendre un ensemble de goroutines 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 « sync.WaitGroup » ?

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

← Retour à Go Academy