Чем errgroup удобнее ручного управления горутинами через WaitGroup + channel для ошибок?

Что такое errgroup и зачем он нужен?

Пакет golang.org/x/sync/errgroup предоставляет удобную абстракцию для работы с группой горутин, где каждая может завершиться ошибкой. Основная задача errgroup — упростить сбор ошибок и управление жизненным циклом горутин по сравнению с ручным использованием sync.WaitGroup и каналов.

Ручной подход с WaitGroup и каналом

При ручном управлении вам нужно создать WaitGroup, канал для ошибок (или использовать атомарные переменные), запустить горутины, дождаться их завершения и обработать ошибки. Это требует написания шаблонного кода и внимательного управления состоянием.

var wg sync.WaitGroup
ch := make(chan error, 3)
for i := 0; i < 3; i++ {
    wg.Add(1)
    go func(id int) {
        defer wg.Done()
        if err := doWork(id); err != nil {
            ch <- err
        }
    }(i)
}
wg.Wait()
close(ch)
for err := range ch {
    if err != nil {
        // обработка первой ошибки
    }
}

Подход с errgroup

Errgroup автоматически создаёт контекст с отменой, запускает горутины через g.Go() и возвращает первую ошибку через g.Wait(). Если любая горутина возвращает ошибку, контекст отменяется, и остальные горутины могут это обнаружить.

g, ctx := errgroup.WithContext(context.Background())
for i := 0; i < 3; i++ {
    id := i
    g.Go(func() error {
        return doWork(id)
    })
}
if err := g.Wait(); err != nil {
    // обработка первой ошибки
}

Ключевые преимущества errgroup

• Автоматическая отмена контекста — при первой ошибке контекст отменяется, что позволяет остановить остальные горутины.
• Сбор первой ошибки — не нужно писать логику выбора первой ошибки из канала.
• Меньше шаблонного кода — нет необходимости вручную управлять WaitGroup и каналом.
• Безопасность — меньше шансов допустить ошибку синхронизации (например, забыть закрыть канал).

Вывод

Errgroup следует применять, когда нужно запустить несколько горутин, обработать первую возникшую ошибку и отменить остальные. Это особенно полезно в сценариях, где ошибка одной операции делает бессмысленным выполнение остальных, например, при параллельной загрузке данных или выполнении запросов к внешним сервисам.