Récapitulatif - Worker Pool

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

Défi

Facile

Construisons un système de traitement de tâches en utilisant le modèle de pool de travailleurs (worker pool) ! Vous allez créer un pool de travailleurs qui traitent simultanément des tâches de calcul, démontrant ainsi comment les canaux (channels), les goroutines et les WaitGroups collaborent pour gérer efficacement les charges de travail.

Vous organiserez votre code sur deux fichiers :

pool.go : Définissez vos composants et la logique de votre pool de travailleurs.
Créez une structure Task avec les champs ID (int) et Value (int) représentant le travail à effectuer.

Créez une structure Result avec les champs TaskID (int) et Computed (int) représentant le travail terminé.

Implémentez une fonction Worker qui prend un ID de travailleur (int), un canal de tâches en réception seule (<-chan Task), un canal de résultats en envoi seul (chan<- Result), et un pointeur vers un sync.WaitGroup. Chaque travailleur doit :
- Utiliser defer wg.Done() pour signaler la fin de son exécution
- Parcourir le canal des tâches avec range pour traiter chaque tâche
- Pour chaque tâche, calculer le carré de la Value de la tâche
- Envoyer un Result avec le TaskID et le carré calculé
Implémentez une fonction RunPool qui prend le nombre de travailleurs (int) et une tranche (slice) de tâches. Cette fonction doit :
- Créer des canaux tamponnés (buffered channels) pour les tâches et les résultats (utilisez le nombre de tâches comme taille de tampon)
- Démarrer le nombre spécifié de travailleurs en tant que goroutines
- Envoyer toutes les tâches dans le canal des tâches, puis le fermer
- Utiliser une goroutine avec le WaitGroup pour fermer le canal des résultats une fois que tous les travailleurs ont terminé
- Collecter tous les résultats dans une tranche et la retourner
main.go : Lire l'entrée et coordonner le pool de travailleurs.
Lisez le nombre de travailleurs, puis le nombre de tâches. Pour chaque tâche, lisez son ID et sa valeur. Appelez RunPool avec les travailleurs et les tâches, puis affichez chaque résultat au format : Task [TaskID]: [Computed]

Affichez les résultats triés par TaskID par ordre croissant.

Les entrées suivantes seront fournies :

Ligne 1 : Nombre de travailleurs (entier)
Ligne 2 : Nombre de tâches (entier)
Lignes suivantes : Pour chaque tâche, deux lignes - l'ID de la tâche (entier), puis sa valeur (entier)

Par exemple, pour :

Votre sortie devrait être :

Task 1: 9
Task 2: 25
Task 3: 4
Task 4: 49

Les travailleurs traitent les tâches de manière concurrente (3 au carré vaut 9, 5 au carré vaut 25, etc.), et les résultats sont collectés et affichés dans l'ordre par ID de tâche. Avec 2 travailleurs gérant 4 tâches, le travail est réparti efficacement dans le pool.

Essayez vous-même

package main

import (
	"fmt"
	"sort"
)

func main() {
	// Lire le nombre de travailleurs
	var numWorkers int
	fmt.Scanln(&numWorkers)

	// Lire le nombre de tâches
	var numTasks int
	fmt.Scanln(&numTasks)

	// Lire les tâches
	tasks := make([]Task, numTasks)
	for i := 0; i < numTasks; i++ {
		var id, value int
		fmt.Scanln(&id)
		fmt.Scanln(&value)
		tasks[i] = Task{ID: id, Value: value}
	}

	// TODO: Appeler RunPool avec les travailleurs et les tâches

	// TODO: Trier les résultats par TaskID par ordre croissant

	// TODO: Afficher chaque résultat au format : Task [TaskID]: [Computed]
}