0Pricing
Go Academy · Lekcja

Wzorce potoków i etapów

Komponowanie współbieżnych potoków wieloetapowych

Wzorce potoków i etapów to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.

Czym jest potok?

Potok współbieżny to seria etapów połączonych kanałami. Każdy etap odbiera wartości z poprzedniego etapu, przekształca je i wysyła wyniki do następnego, dzięki czemu etapy mogą działać współbieżnie.

Prosty potok trzyetapowy

Generowanie → przekształcanie → odbieranie:

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
}

Wzorzec etapu

Każdy etap jest funkcją, która przyjmuje kanał wejściowy i zwraca kanał wyjściowy. Etapy można łatwo łączyć i niezależnie wykonywać równolegle.

Rozgałęzianie w potoku

Rozdziel etap na N goroutines, aby zrównoleglić operacje intensywnie wykorzystujące procesor:

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

Anulowanie za pomocą context

Do każdego etapu należy przekazać context. Po jego anulowaniu etapy przestają odczytywać dane i zamykają wyjściowe kanały, opróżniając cały potok.

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
}

Backpressure

Należy używać buforowanych kanałów między etapami, aby uniezależnić tempo producenta od tempa konsumenta. Bez buforowania wolny etap zatrzymuje cały potok.

out := make(chan Result, 50) // buffer 50 results

Propagacja błędów

Aby propagować błędy przez potok bez wywoływania panic, należy opakować wartości w strukturę wyniku:

type item struct { val int; err error }

Wzorzec kanału done

Kanał done może być prostszą alternatywą dla context w nieskomplikowanych potokach. Należy zamknąć done, aby zasygnalizować wszystkim etapom, że mają się zatrzymać.

done := make(chan struct{})
defer close(done)

Gwarancje kolejności

Prosty potok zachowuje kolejność, jeśli każdy etap działa sekwencyjnie. Etapy wykonywane równolegle nie zachowują kolejności — w razie potrzeby należy użyć pola z indeksem, aby ponownie uporządkować wyniki w dalszej części potoku.

Potok z WaitGroup

Ostatni etap nie musi zamykać kanału — wystarczy, że będzie iterować po jego zawartości. W mechanizmie fan-in należy użyć WaitGroup, aby zamknąć połączony kanał po zakończeniu wszystkich goroutines producentów.

Zastosowania praktyczne

Typowe zastosowania potoków to przetwarzanie danych ETL, zmiana rozmiaru obrazów, analizowanie logów, systemy kompilacji i obsługa strumieniowych żądań.

Szybkie sprawdzenie

Jak propagować anulowanie przez potok składający się z wielu etapów?

Podsumowanie: wzorzec potoku

Najważniejsze informacje:

  • Etap: func(in <-chan T) <-chan U — łączenie etapów umożliwia tworzenie potoków
  • Anulowanie za pomocą context; backpressure za pomocą buforowanych kanałów
  • Rozgałęzianie wewnątrz etapu umożliwia równoległość
  • Opakowanie wartości w strukturę wyniku umożliwia propagację błędów

Często zadawane pytania

Czy lekcja „Wzorce potoków i etapów” jest bezpłatna?

Tak — pełny tekst „Wzorce potoków i etapów” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Wzorce potoków i etapów”?

Komponowanie współbieżnych potoków wieloetapowych Ćwiczysz Go Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Go Academy?

Nie wymagamy żadnego doświadczenia. Go Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Wzorce potoków i etapów”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Go Academy?

Tak. Każda lekcja Go Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Wzorce potoków i etapów
  2. errgroup do współbieżnej obsługi błędów
  3. Wzorzec semafora
  4. Wykrywanie wycieków i anulowanie
← Powrót do Go Academy