Pipeline- und Stage-Patterns
Nebenläufige Pipelines mit mehreren Stufen zusammensetzen
Pipeline- und Stage-Patterns ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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 eine Pipeline?
Eine nebenläufige Pipeline ist eine Reihe von Stufen, die durch Channels verbunden sind. Jede Stufe empfängt Werte von der vorherigen Stufe, verarbeitet sie und sendet die Ergebnisse an die nächste, sodass die Stufen gleichzeitig ausgeführt werden können.
Einfache Pipeline mit drei Stufen
Generieren → transformieren → verarbeiten:
func generate(nums ...int) <-chan int {
out := make(chan int)
go func() { defer close(out); for _, n := range nums { out <- n } }()
return out
}
func square(in <-chan int) <-chan int {
out := make(chan int)
go func() { defer close(out); for n := range in { out <- n*n } }()
return out
}
for v := range square(generate(2, 3, 4)) {
fmt.Println(v) // 4, 9, 16
}Stufenmuster
Jede Stufe ist eine Funktion, die einen Eingabe-Channel entgegennimmt und einen Ausgabe-Channel zurückgibt. Stufen lassen sich sauber kombinieren und unabhängig voneinander parallelisieren.
Fan-out innerhalb einer Pipeline
Verteilen Sie eine Stufe auf N Goroutinen, um CPU-intensive Verarbeitung zu parallelisieren:
func parallelSquare(in <-chan int, n int) <-chan int {
outs := make([]<-chan int, n)
for i := 0; i < n; i++ {
outs[i] = square(in) // all read from same in
}
return merge(outs...)
}Abbruch mit context
Übergeben Sie jeder Stufe einen Context. Wenn er abgebrochen wird, hören die Stufen auf zu lesen und schließen ihre Ausgabe-Channels, wodurch die gesamte Pipeline beendet wird.
func stage(ctx context.Context, in <-chan int) <-chan int {
out := make(chan int)
go func() {
defer close(out)
for {
select {
case v, ok := <-in:
if !ok { return }
select {
case out <- process(v):
case <-ctx.Done(): return
}
case <-ctx.Done(): return
}
}
}()
return out
}Rückstaudruck
Verwenden Sie gepufferte Channels zwischen den Stufen, um die Geschwindigkeit von Produzent und Konsument zu entkoppeln. Ohne Pufferung hält eine langsame Stufe die gesamte Pipeline auf.
out := make(chan Result, 50) // buffer 50 resultsFehlerweitergabe
Verpacken Sie Werte in einer Ergebnis-Struct, um Fehler durch die Pipeline weiterzugeben, ohne eine Panic auszulösen:
type item struct { val int; err error }Muster mit Done-Channel
Verwenden Sie einen Done-Channel als Alternative zu context für einfachere Pipelines. Schließen Sie done, um allen Stufen zu signalisieren, dass sie anhalten sollen.
done := make(chan struct{})
defer close(done)Garantierte Reihenfolge
Eine einfache Pipeline behält die Reihenfolge bei, wenn jede Stufe sequenziell arbeitet. Parallelisierte Stufen behalten die Reihenfolge nicht bei – verwenden Sie bei Bedarf ein Indexfeld, um die Ergebnisse nachgelagert neu zu ordnen.
Pipeline mit WaitGroup
Die letzte Stufe muss keinen Channel schließen – durchlaufen Sie ihn einfach mit range. Verwenden Sie beim Fan-in eine WaitGroup, um den zusammengeführten Channel zu schließen, nachdem alle Produzent-Goroutinen beendet sind.
Praktische Anwendungsfälle
Häufige Anwendungen von Pipelines sind ETL-Datenverarbeitung, Bildgrößenänderung, Log-Parsing, Build-Systeme und Handler für Streaming-Anfragen.
Schnelltest
Wie geben Sie einen Abbruch durch eine Pipeline mit mehreren Stufen weiter?
Zusammenfassung: Pipeline-Muster
Wichtige Punkte:
- Stufe: func(in <-chan T) <-chan U – zum Erstellen von Pipelines kombinieren
- Abbruch über context; Rückstaudruck über gepufferte Channels
- Fan-out innerhalb einer Stufe für Parallelität
- Werte für die Fehlerweitergabe in einer Ergebnis-Struct verpacken
Häufig gestellte Fragen
Ist die Lektion „Pipeline- und Stage-Patterns“ kostenlos?
Ja — der vollständige Text von „Pipeline- und Stage-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 „Pipeline- und Stage-Patterns“?
Nebenläufige Pipelines mit mehreren Stufen zusammensetzen 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 1 von 4.
Wie lange dauert die Lektion „Pipeline- und Stage-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
- Pipeline- und Stage-Patterns
- errgroup für nebenläufige Fehlerbehandlung
- Semaphore-Pattern
- Leak-Erkennung und Abbruch