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 terminent leur travail : une approche fragile. sync.WaitGroup fournit une méthode appropriée pour 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, vous le décrémentez lorsque la goroutine se termine, et vous 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émente le compteur
        go func(id int) {
            defer wg.Done()  // décrémente une fois terminé
            fmt.Printf("Worker %d finished\n", id)
        }(i)
    }
    
    wg.Wait()  // bloque jusqu'à ce que le compteur soit à 0
    fmt.Println("All workers complete")
}

Les trois méthodes principales sont Add(n) pour augmenter le compteur de n, Done() pour le diminuer de un (ce qui équivaut à Add(-1)), et Wait() pour bloquer jusqu’à ce que le compteur atteigne zéro. Utiliser defer wg.Done() garantit que le compteur est décrémenté même si la goroutine déclenche une panique.

Une erreur courante consiste à appeler Add à l’intérieur de la goroutine au lieu de l’appeler avant. Cela crée une condition de concurrence dans laquelle Wait peut retourner avant que toutes les goroutines soient enregistrées :

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

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

Les WaitGroups sont souvent intégrés dans des structures pour coordonner les opérations concurrentes, ce qui les rend essentiels à la création de types thread-safe en Go.

Défi

Facile

Construisons un gestionnaire de téléchargements qui coordonne plusieurs téléchargements de fichiers concurrents à l’aide de sync.WaitGroup. Votre gestionnaire suivra le moment où tous les téléchargements sont terminés sans dépendre de temporisateurs de veille arbitraires.

Vous organiserez votre code dans deux fichiers :

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

Implémentez une méthode Process(wg *sync.WaitGroup) sur Download qui simule un téléchargement en dormant 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 de WaitGroup est correctement décrémenté.

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 combinée de tous les téléchargements.
main.go : Lisez les informations des téléchargements et orchestrez les téléchargements concurrents.
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 transmettez-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 de fichier (chaîne) et la taille en Ko (entier)

Par exemple, pour :

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

Votre sortie doit montrer les téléchargements qui se terminent (les fichiers plus petits se terminent en premier en raison de temps d’attente 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 essentielle par rapport à l’utilisation de time.Sleep est que wg.Wait() bloque jusqu’à ce que toutes les goroutines signalent leur achèvement avec Done(), ce qui vous fournit une synchronisation précise quelle que soit la durée de chaque téléchargement.

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 slice downloads
	// TODO: Print the summary: "All downloads complete: [total]KB total"
}