sync.WaitGroup

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy — leçon 64 sur 107.

Dans la leçon sur les bases des goroutines, nous avons utilisé time.Sleep pour attendre que les goroutines se terminent — une approche fragile. sync.WaitGroup fournit un moyen approprié d'attendre qu'une collection de goroutines termine son travail.

Un WaitGroup fonctionne comme un compteur. Vous l'incrémentez avant de démarrer une goroutine, le décrémentez quand la goroutine se termine, et bloquez jusqu'à ce que le compteur atteigne zéro :

func main() {
    var wg sync.WaitGroup
    
    for i := 1; i <= 3; i++ {
        wg.Add(1)  // incrémenter le compteur
        go func(id int) {
            defer wg.Done()  // décrémenter une fois terminé
            fmt.Printf("Worker %d finished\n", id)
        }(i)
    }
    
    wg.Wait()  // bloquer jusqu'à ce que le compteur soit à 0
    fmt.Println("All workers complete")
}

Les trois méthodes clés sont Add(n) pour augmenter le compteur de n, Done() pour le diminuer de un (équivalent à Add(-1)), et Wait() pour bloquer jusqu'à ce que le compteur atteigne zéro. L'utilisation de defer wg.Done() garantit que le compteur décrémente même si la goroutine panique.

Une erreur courante consiste à appeler Add à l'intérieur de la goroutine au lieu de le faire avant. Cela crée une condition de concurrence où Wait pourrait se terminer avant que toutes les goroutines ne soient enregistrées :

// Incorrect - condition de concurrence
go func() {
    wg.Add(1)  // pourrait s'exécuter après Wait()
    defer wg.Done()
}()

// Correct - Ajouter avant le lancement
wg.Add(1)
go func() {
    defer wg.Done()
}()

Les WaitGroups sont souvent imbriqués dans des structures pour coordonner des opérations concurrentes, ce qui les rend essentiels pour construire des types thread-safe en Go.

Défi

Facile

Construisons un gestionnaire de téléchargement qui coordonne plusieurs téléchargements de fichiers simultanés à l'aide de sync.WaitGroup. Votre gestionnaire suivra le moment où tous les téléchargements se terminent sans s'appuyer sur des minuteries de sommeil arbitraires.

Vous organiserez votre code sur deux fichiers :

downloader.go : Définissez votre logique de coordination de téléchargement.
Créez une structure Download avec les champs ID (int), Filename (string) et Size (int, représentant les Ko).

Implémentez une méthode Process(wg *sync.WaitGroup) sur Download qui simule le téléchargement en s'endormant pendant une durée basée sur la taille du fichier (utilisez Size * 10 millisecondes). Lorsque le téléchargement est terminé, affichez : Downloaded: [Filename] ([Size]KB). Utilisez defer wg.Done() pour vous assurer que le compteur du WaitGroup décrémente correctement.

Créez une fonction StartDownloads(downloads []Download) int qui lance tous les téléchargements simultanément à l'aide de goroutines et attend qu'ils soient tous terminés. N'oubliez pas d'appeler wg.Add(1) avant de lancer chaque goroutine, et non à l'intérieur de celle-ci. Retournez la taille totale de tous les téléchargements combinés.
main.go : Lisez les informations de téléchargement et orchestrez les téléchargements simultanés.
Lisez le nombre de téléchargements, puis pour chaque téléchargement, lisez son ID, son nom de fichier et sa taille. Créez les téléchargements et passez-les à StartDownloads. Une fois tous les téléchargements terminés, affichez : All downloads complete: [total]KB total

Les entrées suivantes seront fournies :

Ligne 1 : Nombre de téléchargements (entier)
Lignes suivantes : Pour chaque téléchargement, trois lignes - l'ID (entier), le nom du fichier (chaîne de caractères) et la taille en Ko (entier)

Par exemple, étant donné :

3
1
report.pdf
20
2
image.png
5
3
data.csv
10

Votre sortie devrait montrer les téléchargements se terminant (les fichiers plus petits finissent en premier en raison de temps de sommeil plus courts), suivis du résumé :

Downloaded: image.png (5KB)
Downloaded: data.csv (10KB)
Downloaded: report.pdf (20KB)
All downloads complete: 35KB total

La différence clé par rapport à l'utilisation de time.Sleep est que wg.Wait() bloque jusqu'à ce que toutes les goroutines signalent leur achèvement avec Done(), vous offrant une synchronisation précise quel que soit le temps que prend chaque téléchargement.

Aide-mémoire

Un sync.WaitGroup fournit un moyen approprié d'attendre que les goroutines se terminent. Il fonctionne comme un compteur qui suit les goroutines en cours d'exécution.

Les trois méthodes clés sont :

Add(n) - augmente le compteur de n
Done() - diminue le compteur de un (équivalent à Add(-1))
Wait() - bloque jusqu'à ce que le compteur atteigne zéro

Modèle d'utilisation de base :

var wg sync.WaitGroup

for i := 1; i <= 3; i++ {
    wg.Add(1)  // increment before starting goroutine
    go func(id int) {
        defer wg.Done()  // decrement when done
        fmt.Printf("Worker %d finished\n", id)
    }(i)
}

wg.Wait()  // block until all goroutines complete
fmt.Println("All workers complete")

L'utilisation de defer wg.Done() garantit que le compteur décrémente même si la goroutine panique.

Important : Appelez toujours Add avant de lancer la goroutine, et non à l'intérieur de celle-ci, pour éviter les conditions de concurrence (race conditions) :

// Wrong - race condition
go func() {
    wg.Add(1)  // might run after Wait()
    defer wg.Done()
}()

// Correct
wg.Add(1)
go func() {
    defer wg.Done()
}()

Essayez vous-même

package main

import (
	"fmt"
)

func main() {
	// Lire le nombre de téléchargements
	var n int
	fmt.Scanln(&n)

	// Lire les informations de téléchargement
	downloads := make([]Download, n)
	for i := 0; i < n; i++ {
		var id int
		var filename string
		var size int
		fmt.Scanln(&id)
		fmt.Scanln(&filename)
		fmt.Scanln(&size)
		
		downloads[i] = Download{
			ID:       id,
			Filename: filename,
			Size:     size,
		}
	}

	// TODO: Appeler StartDownloads avec la tranche (slice) downloads
	// TODO: Afficher le résumé : "All downloads complete: [total]KB total"
}