Для чего нужен ErrGroup в Go?

Для чего нужен ErrGroup в Go?

ErrGroup (официально errgroup.Group из пакета golang.org/x/sync/errgroup) — это мощный инструмент для параллельного выполнения групп задач с корректной обработкой ошибок и автоматическим прерыванием остальных операций при первой ошибке. Он решает ключевую проблему конкурентного программирования: как безопасно запустить несколько горутин, собрать их результаты/ошибки и гарантировать, что при сбое одной задачи все остальные корректно остановятся.

Основные функции ErrGroup

1. Синхронизация группы горутин с обработкой ошибок

ErrGroup позволяет запустить N горутин через метод Go(f func() error), которые выполняют задачи, возвращающие ошибку. Группа ожидает завершения всех через Wait(), возвращая первую возникшую ошибку (или nil, если все успешно).

import "golang.org/x/sync/errgroup"

func processTasks() error {
    g := &errgroup.Group{}
    
    g.Go(func() error {
        return downloadFile("file1.txt")
    })
    g.Go(func() error {
        return processData("data.json")
    })
    
    return g.Wait() // Ожидает обе горутин, возвращает первую ошибку
}

2. Автоматическое распространение ошибок и остановка

Самое важное — при возникновении ошибки в одной горутине, другие задачи не продолжают бессмысленную работу. Например, если одна часть расчета не удалась, остальные вычисления можно прекратить.

3. Контекст для прерывания операций

ErrGroup интегрируется с context.Context, позволяя создавать группы с контекстом через errgroup.WithContext(ctx). Это дает два преимущества:

• Автоматическое прерывание при ошибке (контекст отменяется)
• Возможность отмены извне через контекст

func parallelFetch(ctx context.Context) error {
    g, ctx := errgroup.WithContext(ctx)
    
    g.Go(func() error {
        // Операция использует ctx, который отменится при ошибке в другой горутине
        resp, err := http.Get(ctx, "https://api.example.com/data")
        if err != nil {
            return err
        }
        defer resp.Body.Close()
        // ... обработка
        return nil
    })
    
    g.Go(func() error {
        // Если здесь возникнет ошибка, контекст отменится и первая горутина тоже прервется
        return validateInput(ctx, someInput)
    })
    
    return g.Wait()
}

Сравнение с базовыми механизмами Go

Простые горутины + sync.WaitGroup

WaitGroup только ожидает завершения, но не обрабатывает ошибки:

var wg sync.WaitGroup
errors := make(chan error, 3)

wg.Add(1)
go func() {
    defer wg.Done()
    if err := task1(); err != nil {
        errors <- err
    }
}()
wg.Wait()

// Дополнительно нужно собирать ошибки из канала

Это требует больше кода и не обеспечивает автоматическое прерывание.

ErrGroup vs другие подходы

• Каналы ошибок: сложнее управлять, нужно явно прерывать другие горутины
• sync.WaitGroup + select: много boilerplate кода
• Паттерн "fan-in": требует сложной координации

Практические примеры использования

Микросервисы: параллельные HTTP запросы

Когда нужно получить данные из нескольких API и агрегировать результат:

func fetchAll(ctx context.Context, urls []string) ([]*Response, error) {
    g, ctx := errgroup.WithContext(ctx)
    responses := make([]*Response, len(urls))
    
    for i, url := range urls {
        g.Go(func() error {
            resp, err := fetchWithContext(ctx, url)
            if err != nil {
                return err
            }
            responses[i] = resp
            return nil
        })
    }
    
    if err := g.Wait(); err != nil {
        return nil, err // Все запросы прервались автоматически
    }
    return responses, nil
}

Обработка данных: параллельные этапы pipeline

При преобразовании данных через несколько этапов:

func transformPipeline(input []Data) error {
    g := &errgroup.Group{}
    
    // Этап 1: фильтрация
    g.Go(func() error {
        return filterInvalid(input)
    })
    
    // Этап 2: нормализация
    g.Go(func() error {
        return normalizeFields(input)
    })
    
    // Этап 3: вычисление статистики
    g.Go(func() error {
        return calculateStats(input)
    })
    
    return g.Wait() // Если фильтрация не удалась, другие этапы прекратятся
}

Ключевые особенности и лучшие практики

1. Одна ошибка возвращается — Wait() возвращает только первую ошибку, даже если несколько горутин завершились с ошибками.
2. Горутины должны быть отменяемыми — при использовании контекста, операции должны проверять ctx.Err().
3. Не блокирующие операции — ErrGroup не предназначен для длительных блокирующих задач без контекста.
4. Ограничение количества горутин — иногда нужно сочетать ErrGroup с semaphore для контроля нагрузки.

Заключение

ErrGroup — это элегантное решение для конкурентных операций с зависимыми результатами, где ошибка в одной части делает остальные вычисления бесполезными или опасными. Он сокращает boilerplate код, обеспечивает безопасность и позволяет легко интегрировать механизмы отмены через контекст. В отличие от простых горутин, ErrGroup добавляет уровень интеллектуального управления ошибками, что критически важно в современных распределенных системах и микросервисных архитектурах.