0Pricing
Go Academy · Lektion

Fan-in- und Fan-out-Patterns

Mehrere Channels zusammenführen und Arbeit verteilen

Fan-in- und Fan-out-Patterns ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist Fan-out?

Fan-out verteilt Arbeit aus einem Kanal auf mehrere Goroutinen und ermöglicht so parallele Verarbeitung. Jeder Worker empfängt aus demselben Eingangskanal.

Fan-out-Beispiel

Starten Sie N Worker, die alle aus einem gemeinsam genutzten jobs-Kanal lesen:

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

Was ist Fan-in?

Fan-in führt mehrere Kanäle in einem zusammen, sodass ein einzelner Konsument Ergebnisse von vielen Produzenten lesen kann.

Fan-in mit Goroutinen

Starten Sie für jeden Eingangskanal eine Goroutine; jede Goroutine leitet Werte an einen gemeinsam genutzten Ausgabekanal weiter.

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
}

Fan-in mit select

Bei einer festen Anzahl von Eingangskanälen ist eine select-Schleife einfacher als eine Goroutine pro Kanal.

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
}

Pipeline-Stufe

Kombinieren Sie Fan-out und Fan-in, um eine Pipeline-Stufe aufzubauen: ein Eingangskanal, N parallele Worker und ein zusammengeführter Ausgabekanal.

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...)
}

Kanäle sauber schließen

Der Sender schließt den Kanal; der Empfänger erkennt das Schließen mithilfe der Zweiwertform beim Empfang oder durch eine Bereichsschleife. Schließen Sie niemals auf der Empfängerseite.

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

Koordination mit WaitGroup

Verwenden Sie sync.WaitGroup, um zu erkennen, wann alle Fan-out-Worker fertig sind. Schließen Sie anschließend den Ausgabekanal, damit nachgelagerte Konsumenten ihre Arbeit beenden können.

Rückstau

Verwenden Sie gepufferte Kanäle zwischen Pipeline-Stufen, um Lastspitzen aufzufangen. Dimensionieren Sie den Puffer anhand des erwarteten Latenzunterschieds zwischen Produzent und Konsument.

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

Fehlerweitergabe

Verpacken Sie Ergebnisse in einer Struktur, die sowohl den Wert als auch einen Fehler enthält, damit Fehler neben den Daten durch die Pipeline fließen, ohne einen Panic auszulösen.

type Result struct {
    Value int
    Err   error
}

Abbruch mit Kontext

Übergeben Sie einen Kontext durch die Pipeline-Stufen und prüfen Sie in jeder Stufe ctx.Done(), damit die gesamte Pipeline bei einem Abbruch stoppt.

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

Kurze Überprüfung

Was schließt bei einem Fan-in-Muster den zusammengeführten Ausgabekanal?

Zusammenfassung: Fan-in und Fan-out

Wichtige Punkte:

  • Fan-out: Mehrere Worker lesen aus einem Kanal
  • Fan-in: Eine Goroutine pro Quelle führt die Werte in einem Ausgabekanal zusammen
  • WaitGroup koordiniert das Schließen des zusammengeführten Kanals
  • Verwenden Sie Kontext für Abbrüche und gepufferte Kanäle für Rückstau

Häufig gestellte Fragen

Ist die Lektion „Fan-in- und Fan-out-Patterns“ kostenlos?

Ja — der vollständige Text von „Fan-in- und Fan-out-Patterns“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Fan-in- und Fan-out-Patterns“?

Mehrere Channels zusammenführen und Arbeit verteilen Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Fan-in- und Fan-out-Patterns“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Die select-Anweisung
  2. Timeouts und Ticker
  3. Fan-in- und Fan-out-Patterns
  4. Worker-Pool-Pattern
← Zurück zu Go Academy