Go Academy · Leçon

Distribution et collecte

Répartir et rassembler le travail

Distribution et collecte est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Distribution et regroupement

La distribution consiste à lancer plusieurs routines Go pour lire depuis un seul canal et répartir le travail. Le regroupement consiste à fusionner les sorties de plusieurs routines Go dans un seul canal.

La distribution répartit la charge entre les agents
Le regroupement rassemble les résultats pour le consommateur

Une étape de génération

La chaîne de traitement commence par un générateur : une fonction qui renvoie un canal et y transmet des valeurs depuis sa propre routine Go, puis le ferme.

func gen(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

Distribuer

Pour distribuer, lancez plusieurs routines Go qui lisent toutes depuis le même canal d'entrée. Chacune exécute la même fonction de traitement et produit son propre canal de sortie.

in := gen(1, 2, 3, 4, 5)
c1 := square(in)
c2 := square(in)

Une étape de traitement

L'étape square lit depuis in, élève chaque valeur au carré et l'envoie vers un nouveau canal de sortie. Plusieurs instances de cette étape partagent une même entrée.

func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

Regrouper avec merge

Le regroupement fusionne plusieurs canaux en un seul. Un sync.WaitGroup suit les routines Go associées à chaque canal, et une routine Go de fermeture attend qu'elles soient toutes terminées avant de fermer la sortie regroupée.

func merge(cs ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    for _, c := range cs {
        wg.Add(1)
        go func(c <-chan int) {
            for n := range c {
                out <- n
            }
            wg.Done()
        }(c)
    }
    go func() { wg.Wait(); close(out) }()
    return out
}

Pourquoi utiliser WaitGroup

Chaque routine Go de fusion copie un canal d'entrée dans out. Nous ne devons pas fermer out tant que toutes les entrées n'ont pas été entièrement lues. WaitGroup compte les copieurs actifs ; la routine Go de fermeture reste bloquée sur wg.Wait() jusqu'à leur fin.

Capturer la variable de boucle

Dans les anciennes versions de Go, la fonction de fermeture doit recevoir c comme paramètre afin que chaque routine Go associe son propre canal, plutôt que la variable de boucle partagée. Passer c explicitement évite le célèbre bogue de la variable de boucle.

Une distribution et un regroupement complets

Ce programme génère des nombres, les distribue vers deux étapes square, puis regroupe les résultats et additionne la sortie fusionnée.

package main

import (
    "fmt"
    "sync"
)

func gen(nums ...int) <-chan int {
    out := make(chan int)
    go func() { for _, n := range nums { out <- n }; close(out) }()
    return out
}

func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() { for n := range in { out <- n * n }; close(out) }()
    return out
}

func merge(cs ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    for _, c := range cs {
        wg.Add(1)
        go func(c <-chan int) { for n := range c { out <- n }; wg.Done() }(c)
    }
    go func() { wg.Wait(); close(out) }()
    return out
}

func main() {
    in := gen(1, 2, 3, 4, 5)
    c1 := square(in)
    c2 := square(in)
    total := 0
    for n := range merge(c1, c2) {
        total += n
    }
    fmt.Println("sum of squares:", total)
}

L'ordre n'est pas garanti

Comme deux étapes square se concurrencent sur la même entrée, l'ordre de la sortie fusionnée est non déterministe. Si vous avez besoin de conserver l'ordre, associez un index à chaque élément ou utilisez une seule étape.

Quand distribuer

Distribuez lorsque le traitement d'une étape constitue le goulot d'étranglement et que le travail peut être parallélisé. Si le générateur en amont est lent, ajouter des agents en aval n'aidera pas : ils resteront simplement inactifs.

Rétropression

Les canaux sans tampon créent une rétropression naturelle : une étape rapide se bloque lorsqu'un consommateur lent ne peut pas suivre. Cela empêche la croissance illimitée de la mémoire dans la chaîne de traitement.

Vérification rapide

Vérifiez vos connaissances sur le regroupement.

Récapitulatif

Vous avez appris la distribution et le regroupement :

Distribution : plusieurs routines Go lisent depuis un seul canal
Regroupement : fusionner plusieurs canaux en un seul au moyen de WaitGroup
L'ordre n'est pas conservé entre les étapes parallèles
Les canaux sans tampon fournissent une rétropression

Questions Fréquemment Posées

La leçon « Distribution et collecte » est-elle gratuite ?

Oui — le texte complet de « Distribution et collecte » 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 « Distribution et collecte » ?

Répartir et rassembler le travail 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 2 sur 4.

Combien de temps prend la leçon « Distribution et collecte » ?

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