Récapitulatif - Pool de workers

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 des tâches à l'aide du modèle de pool de workers ! Vous allez créer un pool de workers qui traitent simultanément des tâches de calcul, afin de montrer comment les canaux, les goroutines et les WaitGroups fonctionnent ensemble pour gérer efficacement les charges de travail.

Vous organiserez votre code sur deux fichiers :

pool.go : définir les composants et la logique de votre pool de workers.
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 worker (int), un canal de réception de tâches (<-chan Task), un canal d'envoi des résultats (chan<- Result) et un pointeur vers un sync.WaitGroup. Chaque worker doit :
- Utiliser defer wg.Done() pour signaler la fin de son exécution
- Parcourir le canal de tâches pour traiter chaque tâche
- Pour chaque tâche, calculer le carré de sa valeur
- Envoyer un Result contenant le TaskID et le carré calculé
Implémentez une fonction RunPool qui prend le nombre de workers (int) et une tranche de tâches. Cette fonction doit :
- Créer des canaux tamponnés pour les tâches et les résultats (utiliser le nombre de tâches comme taille du tampon)
- Démarrer le nombre indiqué de workers sous forme de goroutines
- Envoyer toutes les tâches sur le canal de tâches, puis le fermer
- Utiliser une goroutine avec le WaitGroup pour fermer le canal de résultats lorsque tous les workers ont terminé
- Rassembler tous les résultats dans une tranche et la retourner
main.go : lire les entrées et coordonner le pool de workers.
Lisez le nombre de workers, puis le nombre de tâches. Pour chaque tâche, lisez son ID et sa valeur. Appelez RunPool avec les workers et les tâches, puis affichez chaque résultat au format : Task [TaskID]: [Computed]

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

Les entrées suivantes seront fournies :

Ligne 1 : nombre de workers (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, avec :

Votre sortie doit être :

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

Les workers traitent les tâches simultanément (3 au carré vaut 9, 5 au carré vaut 25, etc.), et les résultats sont rassemblés et affichés dans l'ordre des ID des tâches. Avec 2 workers prenant en charge 4 tâches, le travail est réparti efficacement au sein du 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]
}