0Pricing
Go Academy · Lekcja

errgroup do współbieżnej obsługi błędów

golang.org/x/sync/errgroup w praktyce

errgroup do współbieżnej obsługi błędów to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 2 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.

Problem goroutines i błędów

Uruchomienie goroutines za pomocą go func() odrzuca wartości zwracane, w tym błędy. Do ich zebrania potrzebne są dodatkowe mechanizmy (kanały, WaitGroup). errgroup upraszcza to zadanie.

golang.org/x/sync/errgroup

errgroup.Group uruchamia goroutines i zbiera błędy. Wait() blokuje wykonanie do czasu zakończenia wszystkich goroutines i zwraca pierwszy błąd różny od nil.

var g errgroup.Group
g.Go(func() error { return fetchUsers() })
g.Go(func() error { return fetchOrders() })
if err := g.Wait(); err != nil {
    log.Fatal(err)
}

errgroup.WithContext

WithContext zwraca grupę i pochodny context. Context zostaje anulowany, gdy pierwsza goroutine zwróci błąd, co zatrzymuje pozostałe operacje.

g, ctx := errgroup.WithContext(context.Background())
g.Go(func() error { return doWork(ctx) })
g.Go(func() error { return doOtherWork(ctx) })
err := g.Wait()

Zbieranie wyników wraz z błędami

errgroup zbiera tylko błędy, a nie wyniki. Aby uniknąć synchronizacji, wyniki należy przechwytywać we wstępnie zaalokowanych slice’ach, korzystając z indeksu:

results := make([]Result, len(items))
for i, item := range items {
    i, item := i, item
    g.Go(func() error {
        r, err := process(ctx, item)
        if err != nil { return err }
        results[i] = r
        return nil
    })
}
if err := g.Wait(); err != nil { return err }

g.SetLimit (Go 1.20+)

g.SetLimit(n) ogranicza liczbę jednocześnie działających goroutines — pełni funkcję wbudowanego semafora bez używania osobnego kanału.

g.SetLimit(10) // at most 10 goroutines at once
for _, item := range items {
    g.Go(func() error { return process(item) })
}

g.TryGo

g.TryGo(f) uruchamia goroutine tylko wtedy, gdy pozwala na to limit ustawiony przez SetLimit. Zwraca false, jeśli goroutine nie została uruchomiona.

Zwracany jest tylko pierwszy błąd

errgroup zwraca tylko pierwszy błąd. Jeśli potrzebne są wszystkie błędy, należy zbierać je w chronionym przez mutex slice’ie wewnątrz każdej goroutine.

var mu sync.Mutex
var errs []error
g.Go(func() error {
    if err := doWork(); err != nil {
        mu.Lock(); errs = append(errs, err); mu.Unlock()
    }
    return nil
})

Różnica względem sync.WaitGroup

WaitGroup śledzi zakończenie pracy, a errgroup śledzi zakończenie pracy ORAZ zbiera błędy. Należy preferować errgroup, gdy błąd dowolnej goroutine powinien zostać zgłoszony.

Propagacja anulowania context

Po użyciu errgroup.WithContext anulowanie pochodnego context sygnalizuje wszystkim pozostałym goroutines, aby się zatrzymały — podobnie jak w modelu anulowania po pierwszym błędzie.

Testowanie kodu z errgroup

W testach należy wstrzyknąć context z WithTimeout, aby mieć pewność, że grupa nie będzie działać bez końca, jeśli jedna z goroutines się zawiesi.

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
g, ctx := errgroup.WithContext(ctx)

Alternatywa dla semafora

Przed wprowadzeniem SetLimit (Go < 1.20) można było użyć buforowanego kanału jako semafora wewnątrz poszczególnych goroutines, aby uzyskać ten sam efekt.

Szybkie sprawdzenie

Co zwraca errgroup.WithContext, czego nie zwraca zwykły errgroup.Group?

Podsumowanie: errgroup

Najważniejsze informacje:

  • g.Go(func() error) — uruchamia zadanie i zbiera pierwszy błąd
  • g.Wait() — blokuje do zakończenia wszystkich zadań; zwraca pierwszy błąd
  • WithContext — context zostaje anulowany po pierwszym błędzie
  • g.SetLimit(n) — ogranicza liczbę równoczesnych goroutines (Go 1.20+)

Często zadawane pytania

Czy lekcja „errgroup do współbieżnej obsługi błędów” jest bezpłatna?

Tak — pełny tekst „errgroup do współbieżnej obsługi błędó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 „errgroup do współbieżnej obsługi błędów”?

golang.org/x/sync/errgroup w praktyce Ć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 2 z 4.

Ile czasu zajmuje lekcja „errgroup do współbieżnej obsługi błędó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