Worker Pool em Go


O padrão Worker Pool é uma solução simples e eficiente para controlar concorrência e distribuir tarefas entre múltiplas goroutines sem sobrecarregar o sistema. Ele é amplamente usado em pipelines, processamento de arquivos, filas de mensagens, scrapers e qualquer workload paralelo.
Neste post, você verá:
É um padrão onde você cria:
Isso evita a criação descontrolada de goroutines e melhora o uso de CPU.
Use quando precisar:
[Tarefas] → [Channel] → [Workers concorrentes] → [Resultados]
Simples, eficiente e previsível.
Abaixo, um Worker Pool funcional com workers dinâmicos e controle de concorrência:
package main import ( "fmt" "time" ) func worker(id int, jobs <-chan int, results chan<- int) { for job := range jobs { fmt.Printf("Worker %d processando tarefa %d\n", id, job) time.Sleep(time.Second) // simula trabalho results <- job * 2 } } func main() { jobs := make(chan int, 10) results := make(chan int, 10) // cria 3 workers for w := 1; w <= 3; w++ { go worker(w, jobs, results) } // envia 5 tarefas for j := 1; j <= 5; j++ { jobs <- j } close(jobs) // recebe resultados for r := 1; r <= 5; r++ { fmt.Println("Resultado:", <-results) } }
O Worker Pool é um padrão simples, porém extremamente poderoso para lidar com concorrência no Go. Ele evita explosão de goroutines, melhora a performance e mantém o controle total sobre o processamento paralelo.
Se você trabalha com pipelines, filas ou alto volume de tarefas, esse padrão é indispensável.
The Worker Pool pattern is a simple and efficient solution to control concurrency and distribute tasks among multiple goroutines without overloading the system. It is widely used in pipelines, file processing, message queues, scrapers, and any parallel workload.
In this post, you will see:
It is a pattern where you create:
This avoids the uncontrolled creation of goroutines and improves CPU usage.
Use it when you need to:
[Tasks] → [Channel] → [Concurrent Workers] → [Results]
Simple, efficient, and predictable.
Below, a functional Worker Pool with dynamic workers and concurrency control:
package main import ( "fmt" "time" ) func worker(id int, jobs <-chan int, results chan<- int) { for job := range jobs { fmt.Printf("Worker %d processing task %d\n", id, job) time.Sleep(time.Second) // simulates work results <- job * 2 } } func main() { jobs := make(chan int, 10) results := make(chan int, 10) // creates 3 workers for w := 1; w <= 3; w++ { go worker(w, jobs, results) } // sends 5 tasks for j := 1; j <= 5; j++ { jobs <- j } close(jobs) // receives results for r := 1; r <= 5; r++ { fmt.Println("Result:", <-results) } }
The Worker Pool is a simple yet extremely powerful pattern for handling concurrency in Go. It avoids goroutine explosion, improves performance, and maintains total control over parallel processing.
If you work with pipelines, queues, or high volume of tasks, this pattern is indispensable.