Как ограничить количество горутин при параллельной обработке в Go?

Параллельная обработка с ограничением числа горутин

• контекст: конкурентность в Go
• задача: контролировать количество одновременно выполняющихся горутин, чтобы рационально расходовать ресурсы
• решение: применить буферизированный канал в роли семафора
• принцип: перед созданием горутины помещать "токен" в канал, а после её завершения извлекать его; это блокирует запуск сверх установленного лимита
• альтернатива: worker pool, в котором фиксированное число воркеров получает задачи из канала
• пример: go sem := make(chan struct{}, limit) for _, task := range tasks { sem <- struct{}{} go func(t Task) { defer func() { <-sem }() process(t) }(task) }
• результат: управление параллелизмом помогает избежать перегрузки и контролировать использование памяти и CPU

Этот подход надёжен и широко применяется в Go-проектах для равномерного распределения нагрузки.

Подробный ответ

Основной ответ

Чтобы выполнять задачи параллельно, ограничивая число горутин в Go, часто выбирают паттерн пул воркеров (worker pool). В рамках этого подхода запускается заранее определённое количество горутин, которые одновременно получают задания из общей очереди — канала. Благодаря этому верхняя граница числа работающих горутин остаётся фиксированной, а система не сталкивается с избыточным расходом ресурсов и перегрузкой.

Ключевые моменты

• Для очереди заданий применяйте буферизированный канал: основная горутина помещает в него задачи, а фиксированное количество воркеров извлекает их и выполняет.
• Число воркеров задаётся через запуск строго N горутин, где N обозначает допустимый максимум параллелизма. В качестве значения можно использовать, например, runtime.NumCPU() или конкретное заданное число.
• Для ожидания обработки всех заданий используйте sync.WaitGroup. После завершения работы необходимо корректно закрыть канал и завершить воркеры.
• Другой вариант — семафор на основе канала с capacity = N. Он позволяет динамически ограничивать количество горутин, запускаемых одновременно, когда задачи создаются ad-hoc.

Практический контекст

В высоконагруженных сервисах этот паттерн помогает управлять concurrency, поддерживая стабильную и предсказуемую работу. Например, при запросах к базе данных или внешним API чрезмерный параллелизм может привести к таймаутам и исчерпанию доступных ресурсов. В Go 1.18+ для отмены операций и задания таймаутов при обработке задач также можно применять контексты (context.Context).

Пример кода простого пула воркеров:

tasks := make(chan Task, 100)
var wg sync.WaitGroup

workerCount := 5
for i := 0; i < workerCount; i++ {
wg.Add(1)
go func() {
defer wg.Done()
for task := range tasks {
task.Process()
}
}()
}

// Добавляем задачи
for _, t := range taskList {
tasks <- t
}
close(tasks)
wg.Wait()

Этот паттерн обеспечивает одновременную работу ровно 5 горутин, тогда как остальные задачи остаются в очереди и обрабатываются по мере освобождения воркеров.