Go Academy · Leçon

Modèles fan-in et fan-out

Fusionner plusieurs canaux et répartir le travail

Modèles fan-in et fan-out est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 3 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 que la répartition ?

La répartition distribue le travail d’un canal entre plusieurs routines Go, ce qui permet un traitement en parallèle. Chaque travailleur reçoit les tâches depuis le même canal d’entrée.

Exemple de répartition

Lancez N travailleurs qui lisent tous depuis un canal partagé de tâches :

func fanOut(jobs <-chan Job, n int) {
    for i := 0; i < n; i++ {
        go func() {
            for job := range jobs {
                process(job)
            }
        }()
    }
}

Qu’est-ce que l’agrégation ?

L’agrégation fusionne plusieurs canaux en un seul, afin qu’un consommateur puisse lire les résultats de nombreux producteurs.

Agrégation avec des routines Go

Lancez une routine Go par canal d’entrée ; chacune transmet les valeurs vers un canal de sortie partagé.

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

Agrégation avec sélection

Pour un nombre fixe de canaux d’entrée, une boucle de sélection est plus simple que de lancer une routine Go par canal.

func merge(a, b <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for a != nil || b != nil {
            select {
            case v, ok := <-a: if !ok { a = nil } else { out <- v }
            case v, ok := <-b: if !ok { b = nil } else { out <- v }
            }
        }
    }()
    return out
}

Étape de chaîne de traitement

Combinez répartition et agrégation pour créer une étape de chaîne de traitement : un canal d’entrée, N travailleurs parallèles et un canal de sortie fusionné.

func parallelStage(in <-chan Work, n int) <-chan Result {
    outs := make([]<-chan Result, n)
    for i := 0; i < n; i++ {
        outs[i] = worker(in)
    }
    return fanIn(outs...)
}

Fermer proprement les canaux

L’émetteur ferme le canal ; le récepteur détecte la fermeture avec la forme de réception à deux valeurs ou en parcourant le canal. Ne fermez jamais un canal depuis le côté récepteur.

for v := range in { // exits when in is closed
    process(v)
}

Coordination avec WaitGroup

Utilisez sync.WaitGroup pour savoir quand tous les travailleurs de la répartition ont terminé, puis fermez le canal de sortie afin que les consommateurs en aval puissent terminer.

Rétropression

Utilisez des canaux tamponnés entre les étapes de la chaîne de traitement pour absorber les rafales. Dimensionnez le tampon en fonction de la différence de latence attendue entre le producteur et le consommateur.

out := make(chan Result, 100) // buffer absorbs bursts

Propagation des erreurs

Enveloppez les résultats dans une structure contenant à la fois la valeur et l’erreur, afin que les erreurs traversent la chaîne de traitement avec les données sans provoquer de panique.

type Result struct {
    Value int
    Err   error
}

Annulation par contexte

Transmettez un contexte à travers les étapes de la chaîne de traitement et vérifiez ctx.Done() dans chaque étape afin que toute la chaîne s’arrête lorsqu’elle est annulée.

case <-ctx.Done():
    return ctx.Err()

Vérification rapide

Dans un schéma d’agrégation, qu’est-ce qui ferme le canal de sortie fusionné ?

Récapitulatif : agrégation et répartition

Points essentiels :

Répartition : plusieurs travailleurs lisent depuis un canal
Agrégation : une routine Go par source fusionne les données dans un canal de sortie
WaitGroup coordonne la fermeture du canal fusionné
Utilisez un contexte pour l’annulation et des canaux tamponnés pour la rétropression

Questions Fréquemment Posées

La leçon « Modèles fan-in et fan-out » est-elle gratuite ?

Oui — le texte complet de « Modèles fan-in et fan-out » 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èles fan-in et fan-out » ?

Fusionner plusieurs canaux et répartir 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 3 sur 4.

Combien de temps prend la leçon « Modèles fan-in et fan-out » ?

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