Go Academy · Lekcja

Wzorce fan-in i fan-out

Scalanie wielu kanałów i rozdzielanie pracy

Wzorce fan-in i fan-out to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 3 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 fan-out?

Fan-out rozdziela pracę z jednego kanału między wiele gorutyn, umożliwiając przetwarzanie równoległe. Każdy pracownik odbiera dane z tego samego kanału wejściowego.

Przykład fan-out

Należy uruchomić N pracowników, z których każdy odczytuje dane ze współdzielonego kanału jobs:

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

Czym jest fan-in?

Fan-in scala wiele kanałów w jeden, dzięki czemu pojedynczy konsument może odczytywać wyniki od wielu producentów.

Fan-in z użyciem gorutyn

Należy uruchomić gorutynę dla każdego kanału wejściowego; każda gorutyna przekazuje wartości do współdzielonego kanału wyjściowego.

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 z użyciem select

W przypadku stałej liczby kanałów wejściowych pętla select jest prostsza niż uruchamianie osobnej gorutyny dla każdego kanału.

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
}

Etap potoku

Połączenie fan-out i fan-in pozwala zbudować etap potoku: jeden kanał wejściowy, N równoległych pracowników i jeden połączony kanał wyjściowy.

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

Prawidłowe zamykanie kanałów

Nadawca zamyka kanał; odbiorca wykrywa zamknięcie za pomocą formy odbioru z dwiema wartościami albo przez iterację range. Nigdy nie należy zamykać kanału po stronie odbiorcy.

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

Koordynacja za pomocą WaitGroup

Należy użyć sync.WaitGroup, aby wiedzieć, kiedy wszyscy pracownicy fan-out zakończą pracę, a następnie zamknąć kanał wyjściowy, aby konsumenci niższego etapu mogli zakończyć działanie.

Presja wsteczna

Należy używać buforowanych kanałów między etapami potoku, aby absorbować nagłe wzrosty obciążenia. Rozmiar bufora należy dobrać na podstawie oczekiwanej różnicy opóźnień między producentem a konsumentem.

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

Propagowanie błędów

Należy opakować wyniki w strukturę zawierającą zarówno wartość, jak i błąd, aby błędy przepływały przez potok razem z danymi bez wywoływania panic.

type Result struct {
    Value int
    Err   error
}

Anulowanie za pomocą kontekstu

Należy przekazywać kontekst przez etapy potoku i sprawdzać ctx.Done() w każdym etapie, aby cały potok zatrzymał się po anulowaniu.

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

Szybkie sprawdzenie

W schemacie fan-in co zamyka połączony kanał wyjściowy?

Podsumowanie: fan-in i fan-out

Najważniejsze informacje:

Fan-out: wielu pracowników odczytuje dane z jednego kanału
Fan-in: jedna gorutyna dla każdego źródła scala dane w jeden kanał wyjściowy
WaitGroup koordynuje zamknięcie połączonego kanału
Do anulowania należy używać kontekstu, a do obsługi presji wstecznej — buforowanych kanałów

Często zadawane pytania

Czy lekcja „Wzorce fan-in i fan-out” jest bezpłatna?

Tak — pełny tekst „Wzorce fan-in i fan-out” 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 fan-in i fan-out”?

Scalanie wielu kanałów i rozdzielanie pracy Ć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 3 z 4.

Ile czasu zajmuje lekcja „Wzorce fan-in i fan-out”?

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

← Powrót do Go Academy