Go Academy · Leçon

Modèle de pool de travailleurs

Construire un pool de travailleurs à nombre fixe de goroutines

Modèle de pool de travailleurs est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Qu’est-ce qu’un pool de travailleurs ?

Un pool de travailleurs crée à l’avance un nombre fixe de routines Go qui traitent les tâches d’une file d’attente partagée. Cela limite le parallélisme et empêche l’épuisement des ressources dû à la création illimitée de routines Go.

Implémentation de base

Créez un canal de tâches et N routines Go qui y lisent toutes :

func workerPool(n int, jobs <-chan Job, results chan<- Result) {
    var wg sync.WaitGroup
    for i := 0; i < n; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                results <- process(job)
            }
        }()
    }
    wg.Wait()
    close(results)
}

Envoi des tâches

Envoyez toutes les tâches dans le canal, puis fermez-le. Les travailleurs traiteront toutes les tâches et sortiront de leurs boucles de parcours lorsque le canal sera fermé.

jobs := make(chan Job, 100)
for _, j := range allJobs {
    jobs <- j
}
close(jobs) // signals workers to stop after draining

Collecte des résultats

Lisez les résultats en parallèle de l’envoi des tâches. Utilisez une routine Go pour le pool afin que la collecte des résultats ne provoque pas d’interblocage avec l’envoi des tâches.

results := make(chan Result, 100)
go workerPool(5, jobs, results)
for r := range results {
    collect(r)
}

Réglage de la taille du pool

Pour les tâches limitées par le processeur, définissez la taille du pool sur runtime.NumCPU(). Pour les tâches limitées par les entrées-sorties, un multiplicateur plus élevé (par exemple 10×) permet de mieux utiliser les temps d’attente. Faites du profilage pour trouver le meilleur compromis.

n := runtime.NumCPU()
if ioHeavy { n = runtime.NumCPU() * 10 }

Ajout de l’annulation par contexte

Transmettez un contexte aux travailleurs afin qu’ils s’arrêtent rapidement en cas d’annulation :

for {
    select {
    case job, ok := <-jobs:
        if !ok { return }
        results <- process(ctx, job)
    case <-ctx.Done():
        return
    }
}

Alternative avec sémaphore

Au lieu d’un pool fixe de routines Go, utilisez un canal tamponné comme sémaphore pour limiter le nombre de routines Go exécutées simultanément, tout en lançant une routine Go par tâche.

sem := make(chan struct{}, 10)
for _, job := range jobs {
    sem <- struct{}{}
    go func(j Job) {
        defer func() { <-sem }()
        process(j)
    }(job)
}

Gestion des erreurs

Renvoyez les erreurs avec les résultats au moyen d’une structure de résultat. Annulez le contexte à la première erreur ou rassemblez toutes les erreurs pour produire un rapport final.

type Result struct{ Val int; Err error }

Dimensionnement dynamique du pool

Pour les pools adaptatifs, utilisez golang.org/x/sync/semaphore, qui permet d’acquérir et de libérer une ressource pondérée et prend en charge des limites de parallélisme dynamiques.

Pool de travailleurs ou errgroup

golang.org/x/sync/errgroup fournit une API plus simple pour lancer N routines Go et récupérer la première erreur. Utilisez un pool lorsque vous avez besoin d’un ensemble permanent de travailleurs réutilisables.

Arrêt progressif

Fermez le canal de tâches pour signaler aux travailleurs de s’arrêter. Une fois le WaitGroup terminé, fermez les résultats. Tout envoi de tâche en attente doit avoir lieu avant close(jobs).

Vérification rapide

Comment un pool de travailleurs signale-t-il aux travailleurs d’arrêter le traitement ?

Récapitulatif : pool de travailleurs

Points essentiels :

N routines Go fixes lisent depuis un canal de tâches
Fermez le canal de tâches pour signaler aux travailleurs de terminer
WaitGroup suit l’achèvement ; fermez les résultats une fois le traitement terminé
Tâches limitées par le processeur : taille du pool ≈ NumCPU ; tâches limitées par les entrées-sorties : taille plus importante

Questions Fréquemment Posées

La leçon « Modèle de pool de travailleurs » est-elle gratuite ?

Oui — le texte complet de « Modèle de pool de travailleurs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Modèle de pool de travailleurs » ?

Construire un pool de travailleurs à nombre fixe de goroutines Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Modèle de pool de travailleurs » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy