Pipeline-Stufen
Channel-Stufen verketten
Pipeline-Stufen 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 eine Pipeline
Eine Pipeline ist eine Reihe von Stufen, die durch Kanäle verbunden sind. Jede Stufe empfängt Werte, verarbeitet sie und sendet Ergebnisse an nachgelagerte Stufen. Die Daten fließen dabei wie auf einem Fließband.
- Jede Stufe ist eine Goroutine
- Stufen kommunizieren ausschließlich über Kanäle
- Kombinierbar und leicht nachvollziehbar
Konvention für Stufensignaturen
Konventionell nimmt jede Stufe einen oder mehrere Nur-Lese-Eingangskanäle entgegen und gibt einen Nur-Lese-Ausgangskanal zurück. Dadurch lassen sich Stufen miteinander verketten.
func stage(in <-chan int) <-chan int {
out := make(chan int)
go func() {
defer close(out)
for v := range in {
out <- v
}
}()
return out
}Die Quellstufe
Die erste Stufe erzeugt Daten. Sie nimmt häufig einen Slice oder variadische Argumente entgegen und streamt sie in einen Kanal.
func numbers(vals ...int) <-chan int {
out := make(chan int)
go func() {
defer close(out)
for _, v := range vals {
out <- v
}
}()
return out
}Eine Transformationsstufe
Diese Stufe multipliziert jeden Wert mit zehn. Sie liest aus in und schreibt den transformierten Wert nach out.
func tenfold(in <-chan int) <-chan int {
out := make(chan int)
go func() {
defer close(out)
for v := range in {
out <- v * 10
}
}()
return out
}Eine Filterstufe
Ein Filter leitet nur Werte weiter, die eine Bedingung erfüllen. Hier behalten wir gerade Zahlen und verwerfen den Rest.
func evens(in <-chan int) <-chan int {
out := make(chan int)
go func() {
defer close(out)
for v := range in {
if v%2 == 0 {
out <- v
}
}
}()
return out
}Stufen verketten
Setzen Sie Stufen zusammen, indem Sie eine Ausgabe als nächste Eingabe übergeben. Die Kette liest sich fast wie ein Satz.
pipe := tenfold(evens(numbers(1, 2, 3, 4)))
for v := range pipe {
fmt.Println(v)
}defer close(out)
Die Verwendung von defer close(out) garantiert, dass der Ausgangskanal geschlossen wird, sobald die Stufen-Goroutine zurückkehrt, selbst wenn Sie später vorzeitige Rückgaben hinzufügen. Dadurch wird das Signal für das Ende des Datenstroms an nachgelagerte Stufen weitergegeben.
Eine vollständige Pipeline
Quelle, dann Filter, dann Transformation. Führen Sie das Programm aus, um nur das Zehnfache gerader Eingaben zu sehen.
package main
import "fmt"
func numbers(vals ...int) <-chan int {
out := make(chan int)
go func() { defer close(out); for _, v := range vals { out <- v } }()
return out
}
func evens(in <-chan int) <-chan int {
out := make(chan int)
go func() { defer close(out); for v := range in { if v%2 == 0 { out <- v } } }()
return out
}
func tenfold(in <-chan int) <-chan int {
out := make(chan int)
go func() { defer close(out); for v := range in { out <- v * 10 } }()
return out
}
func main() {
for v := range tenfold(evens(numbers(1, 2, 3, 4, 5, 6))) {
fmt.Println(v)
}
}Streaming statt Batch-Verarbeitung
Werte fließen einzeln durch die Pipeline, sobald sie erzeugt werden. Die Transformationsstufe kann mit der Verarbeitung des ersten Elements beginnen, bevor die Quelle das letzte ausgegeben hat. Dadurch bleiben Speicherbedarf und Latenz gering.
Pipelines arbeiten bedarfsgesteuert
Eine Stufe arbeitet erst, wenn etwas aus ihrer Ausgabe liest. Wenn der Consumer die Bereichsschleife beendet, blockieren vorgelagerte Stufen beim Senden. Diese natürliche Backpressure verhindert unnötige Berechnungen.
Parallelität hinzufügen
Um eine langsame Stufe zu beschleunigen, vervielfachen Sie sie zu mehreren Instanzen, die aus demselben Eingang lesen, und führen Sie deren Ausgaben zusammen. Die Signatur der Stufe bleibt unverändert; nur die Verdrahtung ändert sich.
Kurztest
Testen Sie Ihr Wissen über Pipelines.
Zusammenfassung
Sie haben Pipeline-Stufen gelernt:
- Jede Stufe: Nur-Lese-Eingang, gibt einen Nur-Lese-Ausgang zurück
defer close(out)gibt das Ende des Datenstroms weiter- Stufen durch Verschachteln von Aufrufen verketten
- Pipelines streamen bedarfsgesteuert und sorgen für Backpressure
Lerne Go mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 51
- Lektionen
- 203
Häufig gestellte Fragen
Ist die Lektion „Pipeline-Stufen“ kostenlos?
Ja — der vollständige Text von „Pipeline-Stufen“ 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-Stufen“?
Channel-Stufen verketten 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 „Pipeline-Stufen“?
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.