Как ограничить максимальное количество одновременно выполняемых горутин?

Зачем ограничивать горутины?

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

Реализация через буферизированный канал

Самый распространенный способ — использовать буферизированный канал как семафор. Размер буфера определяет максимальное количество одновременно работающих горутин.

package main

import (
	"fmt"
	"sync"
)

func main() {
	const maxGoroutines = 3
	sem := make(chan struct{}, maxGoroutines)
	var wg sync.WaitGroup

	for i := 0; i < 10; i++ {
		wg.Add(1)
		sem <- struct{}{} // блокируется, если буфер полон
		go func(id int) {
			defer wg.Done()
			defer func() { <-sem }()
			fmt.Printf("Горутина %d работает\n", id)
		}(i)
	}
	wg.Wait()
}

Альтернативный подход: Worker Pool

Можно создать фиксированное количество воркеров, которые читают задачи из канала. Это более структурированный паттерн.

func worker(id int, jobs <-chan int, wg *sync.WaitGroup) {
	defer wg.Done()
	for job := range jobs {
		fmt.Printf("Воркер %d обрабатывает задачу %d\n", id, job)
	}
}

func main() {
	const numWorkers = 3
	jobs := make(chan int, 10)
	var wg sync.WaitGroup

	for w := 0; w < numWorkers; w++ {
		wg.Add(1)
		go worker(w, jobs, &wg)
	}

	for j := 0; j < 10; j++ {
		jobs <- j
	}
	close(jobs)
	wg.Wait()
}

Вывод

Ограничение параллелизма необходимо для стабильной работы приложений. Используйте буферизированный канал для простых сценариев или worker pool для более сложных задач с очередью.