errgroup как структурная конкурентность: горутины в регионе, отмена по первой ошибке и SetLimit

Регион для горутин

Когда вы разветвляетесь без региона, вы доверяете, что каждая горутина вернётся сама — а один глухой сосед в 2 часа ночи докажет обратное. Голый go — это бесструктурность: у горутины нет точки соединения, её ошибке некуда деться, а время жизни никак не связано с функцией, которая её породила. Структурная конкурентность переворачивает это — конкурентная работа ограничена лексическим регионом, и регион не завершается, пока не завершился каждый потомок. В Go идиома — errgroup:

func loadOrder(ctx context.Context, id string) (*Order, error) {
	g, ctx := errgroup.WithContext(ctx) // затенённый ctx: отменяется первой ошибкой

	var inv Inventory
	var price Pricing
	g.Go(func() error { return fetchInventory(ctx, id, &inv) })
	g.Go(func() error { return fetchPricing(ctx, id, &price) })
	g.Go(func() error { return checkFraud(ctx, id) })

	if err := g.Wait(); err != nil {
		return nil, err // первая ошибка; групповой ctx уже отменён
	}
	return assemble(inv, price), nil
}

Регион определяют три гарантии. Wait возвращается, только когда вернулся каждый колбэк g.Go — ни один потомок не переживёт функцию. Ошибка из Wait — первая ненулевая из всех. А с WithContext групповой контекст отменяется, как только этот первый неудачный колбэк вернулся — соседи получают сигнал остановки без вашей проводки. Рядом едет тихая гарантия: Wait — это ребро happens-before, поэтому паттерн выше — каждый потомок пишет в свою переменную, родитель читает их только после Wait — свободен от гонок без единого мьютекса.

Отмена — сигнал, а не убийство

Вот тонкость, за которую Hook заплатил 28 секундами. errgroup отменяет контекст после того, как неудачный колбэк вернул ошибку — а отмена контекста сама по себе не делает ничего. Ни одна горутина не прерывается, ни одно соединение не закрывается, пока кто-то не следит за ctx.Done(). Соседи в полёте бегут дальше, пока сами не заметят отмену, и отсюда правило против утечек для всего юнита: у каждого тела g.Go должен быть путь возврата через ctx. Передавайте групповой ctx в каждый блокирующий вызов — http.NewRequestWithContext, db.QueryContext, и каждую операцию с каналом оборачивайте в select с веткой ctx.Done(). Потомок, который четыре секунды считает хеш в плотном цикле, так же глух: ему положено проверять ctx.Err() между чанками. Компилятор не подсветит соседа, игнорирующего ctx; подсветит ваш p99.

Первая ошибка побеждает — проектируйте политику отказа

Внутри группа держит один слот ошибки под sync.Once: первый ненулевой возврат сохраняется, каждая последующая ошибка отбрасывается. Этот дефолт кодирует политику всё-или-ничего — идеально для «собери страницу из трёх обязательных вызовов», неверно для «обогати 50 записей, сохрани удавшееся». Для best-effort-разветвления не возвращайте ошибки из колбэков вовсе — записывайте их:

errs := make([]error, len(parts))
var g errgroup.Group // без WithContext: ничто не должно отменять соседей
for i, p := range parts {
	g.Go(func() error {
		errs[i] = process(p) // запись в свой слот; непересекающиеся индексы не требуют мьютекса
		return nil           // никогда не валим группу
	})
}
_ = g.Wait()
return errors.Join(errs...) // nil, только если удалась каждая часть

errors.Join отдаёт полную картину, которую группа выбросила бы. И даже в режиме всё-или-ничего оборачивайте ошибку каждого потомка идентичностью — fmt.Errorf("pricing: %w", err) — потому что единственная выжившая ошибка обязана хотя бы сказать, из которого из двенадцати вызовов она пришла. Выбирайте политику на каждое разветвление явно; молчаливый дефолт имеет привычку становиться случайным контрактом.

SetLimit: встроенный ограниченный параллелизм

Разветвление по 10 000 элементов не должно означать 10 000 одновременных горутин, долбящих один downstream. С появлением SetLimit граница — одна строка:

g, ctx := errgroup.WithContext(ctx)
g.SetLimit(8) // ставить до первого Go; смена при активных потомках — паника
for _, item := range items {
	g.Go(func() error { return convert(ctx, item) }) // блокируется, пока 8 в полёте
}
err := g.Wait()

Механизм важен: при достигнутом лимите g.Go блокирует вызывающего. Сам порождающий цикл становится производителем под backpressure — память ограничена лимитом, а не числом элементов. TryGo — неблокирующий вариант: вместо ожидания возвращает false, для схем «отказать вместо очереди». Это тот же выбор «блокировать или отказывать», на котором строится урок про backpressure.

WaitGroup, errgroup или каналы результатов

Прежде чем тянуться за каналом результатов, спросите: вам реально нужен каждый исход как данные, или достаточно первого отказа и чистого соединения? Три инструмента, одно решение. sync.WaitGroup — чистое соединение: ни ошибок, ни отмены — уместен, когда потомки действительно не могут отказать, и известная ловушка иначе (ошибки логируются в пустоту, а родитель рапортует успех). errgroup добавляет проброс первой ошибки, отмену соседей и лимит конкурентности — дефолт для разветвления с политикой отказа. Каналы результатов — тяжёлый вариант: каждый воркер шлёт типизированный результат или ошибку, потребитель итерирует и решает — необходимо, когда нужен каждый исход как данные, потоковый порядок или частичное потребление, ценой собственноручной хореографии закрытия и осушения (урок про пайплайны). Накладные расходы — честный шум: errgroup это WaitGroup плюс мьютекс, Once и опциональный канал-лимитер — наносекунды рядом с любым вызовом, ради которого стоит разветвляться.