Паттерны конкурентности

worker pool — это фиксированный набор goroutine, которые все читают из одного канала задач и выполняют их параллельно. Запускают N goroutine, каждая в цикле range по каналу; производитель отправляет задачи и закрывает канал, из-за чего цикл range у каждого воркера завершается.

Используют буферизованный канал ёмкости N как счётный семафор: перед началом работы отправляют в него токен (sem <- struct{}{}), а по завершении — принимают. Отправка блокируется, когда в работе уже N токенов, поэтому одновременно выполняется не более N goroutine.

Берите sync.Mutex, чтобы защищать изменяемое состояние, обновляемое на месте — счётчик, кэш или map — он дёшев для коротких критических секций. Берите channel, чтобы передавать владение и координировать goroutine. Оба дают happens-before; выбор — это цена, а не безопасность.

errgroup.Group похож на WaitGroup, но Go запоминает первую ненулевую ошибку, а Wait её возвращает. WithContext отменяет свой context на этой ошибке, чтобы соседи остановились раньше, а SetLimit ограничивает параллелизм. Возвращается только первая ошибка.

Запускают по одной горутине на имя, каждая измеряет testSearcher(ctx, name) и шлёт результат {name, dur, err} в буферизованный канал, который закрывающая горутина close-ит после WaitGroup. Проходят range по каналу, держат результат с наименьшим dur среди успешных и пробрасывают ctx, чтобы отмена останавливала пробы в полёте. Если все упали — возвращают последнюю ошибку.

Переиспользуйте один http.Client (никогда не по одному на запрос) и настройте его Transport: MaxConnsPerHost ограничивает соединения к хосту, MaxIdleConnsPerHost держит тёплые для переиспользования, а IdleConnTimeout закрывает простаивающие. Без настройки всплеск горутин открывает неограниченные сокеты и исчерпывает эфемерные порты. Сочетайте с семафором, чтобы ограничить и число запросов в полёте.

defer resp.Body.Close() стоит после io.ReadAll, а ранний if err != nil возвращает управление, оставляя body незакрытым на пути ошибки. Перенесите defer resp.Body.Close() сразу после проверки ошибки Get, чтобы каждый успешный Get закрывал body и освобождал соединение.

На Go 1.22+ каждая итерация получает свой v, поэтому горутины печатают 1 2 3 в некотором порядке. На Go ≤1.21 они все делили один v, изменяемый циклом, и обычно печатали 3 3 3. Переносимое исправление — v := v внутри цикла или передача v аргументом.

Для CPU-bound работы размер пула — runtime.NumCPU(): лишние goroutine сверх числа ядер дают лишь накладные расходы планировщика. Раздавайте индексы через канал задач; каждый воркер пишет out[i] = heavyCompute(nums[i]) в свой индекс — блокировка не нужна, порядок сохраняется. sync.WaitGroup ждёт завершения всех воркеров.

Используйте два сигнальных канала как пинг-понг: горутина odd ждёт <-odd, печатает, затем сигналит even <- struct{}{}; горутина even делает зеркально. main запускает всё через odd <- struct{}{} и ждёт канал done, который even-горутина закрывает после N. Передача эстафеты обеспечивает строгий порядок без общего состояния.

Запускают по одной goroutine на поставщика, каждая вызывает SearchRPC(ctx, …) и шлёт результаты в буферизованный канал; sync.WaitGroup и закрывающая goroutine делают close после завершения всех. Агрегируют, проходя range по каналу, и пробрасывают ctx, чтобы таймаут отменял все RPC в полёте, а не ждал их.

Паттерн func Main() error: main лишь делает if err := Main(); err != nil { log.Fatal(err) }. Внутри Main после каждой успешной инициализации регистрируйте defer, выполняющий очистку и вкладывающий её ошибку в именованный возврат через errors.Join. Defer-ы идут в LIFO, поэтому Service.Stop раньше SendQueue.Close. Это работает, ведь log.Fatal вызывает os.Exit, пропускающий defer-ы, поэтому они должны жить в Main, не в main.

goroutine, делающая ch <- result после того, как получатель уже вернулся (например, по ранней ошибке или дедлайну), навсегда блокируется на отправке и утекает. Чините через select по отправке и ctx.Done() либо буфер канала по числу отправителей, чтобы отправка не блокировалась после отмены.

Захватывают слот через select сразу по отправке в семафор и по ctx.Done(), чтобы отменённый контекст прерывал ожидание. Каждая работающая goroutine делает select на ctx.Done(), чтобы завершиться раньше, и освобождает токен через defer, поэтому отмена не теряет слоты.