Que dire à l'intervieweur (si on vous demande) "J'utiliserais un pool de workers avec un nombre fixe de workers, un canal pour les tâches et sync.WaitGroup. Les workers exécuteront les requêtes, et le timeout et l'annulation seront contrôlés via le contexte. Je rassemblerai les résultats dans un buffer, protégé par un mutex (ou via un canal séparé)." C'est à ton tour Écris le code dans cette discussion. Je vérifierai et te donnerai un retour. Si tu ne sais pas par où commencer, demande un indice. Bonne chance!

go package main

import ( "context" "fmt" "sync" "time" )

// Task représente une tâche à traiter type Task struct { id int // autres champs }

// WorkerPool implémente un groupe de travailleurs func WorkerPool(ctx context.Context, tasks <-chan Task, results chan<- string, wg *sync.WaitGroup) { defer wg.Done() for { select { case <-ctx.Done(): return case task, ok := <-tasks: if !ok { return } // Traitement de la tâche res := processTask(task) select { case results <- res: case <-ctx.Done(): return } } } }

func processTask(t Task) string { // simulation de travail time.Sleep(100 * time.Millisecond) return fmt.Sprintf("résultat pour la tâche %d", t.id) }

func main() { tasks := make(chan Task) results := make(chan string) var wg sync.WaitGroup

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

workerCount := 5
wg.Add(workerCount)
for i := 0; i < workerCount; i++ {
	go WorkerPool(ctx, tasks, results, &wg)
}

// Goroutine séparée pour fermer le canal de résultats après la fin des travailleurs
go func() {
	wg.Wait()
	close(results)
}()

// Envoi des tâches
go func() {
	for i := 0; i < 20; i++ {
		tasks <- Task{id: i}
	}
	close(tasks)
}()

// Collecte des résultats
for res := range results {
	fmt.Println(res)
}

}