Padrão de pool de trabalhadores
Limite a simultaneidade
Padrão de pool de trabalhadores é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.
O que é um pool de worker
Um pool de worker inicia um número fixo de gorrotinas que extraem tarefas de um canal compartilhado. Em vez de iniciar uma gorrotina por tarefa, você inicia N processos worker e fornece trabalho a eles.
- Limita o número de operações simultâneas
- Reutiliza gorrotinas em vez de criar milhares
- Protege recursos compartilhados, como bancos de dados ou APIs
Por que limitar a concorrência
Gorrotinas sem limite podem esgotar a memória e os descritores de arquivos ou sobrecarregar um serviço secundário. Um pool oferece um controle para determinar quanto trabalho é executado de uma vez.
Se você tiver 10000 URLs para buscar, não vai querer 10000 requisições HTTP simultâneas. Um pool com 20 processos worker mantém a situação sob controle.
O canal jobs
As tarefas fluem para um canal jobs. Cada processo worker lê dele em um laço for range. Quando o canal é fechado, o laço termina e o processo worker sai.
jobs := make(chan int, 100)
for j := 1; j <= 5; j++ {
jobs <- j
}
close(jobs)Um único worker
Um worker é apenas uma função que percorre o canal de tarefas. Ele processa cada tarefa e escreve o resultado em um canal de resultados.
func worker(id int, jobs <-chan int, results chan<- int) {
for j := range jobs {
results <- j * 2
}
}Iniciando vários processos worker
Inicie o pool com um laço simples. Cada iteração inicia uma gorrotina que executa a mesma função worker. Todas compartilham os mesmos canais de tarefas e resultados.
for w := 1; w <= 3; w++ {
go worker(w, jobs, results)
}Tipos de canais direcionais
Observe <-chan int, somente para recebimento, e chan<- int, somente para envio, na assinatura do worker. Esses tipos direcionais permitem que o compilador impeça um processo worker de enviar acidentalmente para o canal de tarefas ou ler do canal de resultados.
Coletando resultados
Depois de fornecer todas as tarefas e fechar o canal, a gorrotina main lê exatamente a mesma quantidade de resultados que havia de tarefas. Isso sincroniza o programa para que ele não termine antes da hora.
sum := 0
for a := 1; a <= 5; a++ {
sum += <-results
}
fmt.Println("total:", sum)Um pool completo e executável
Aqui está o padrão completo em um único programa: três processos worker duplicam cinco números. Execute-o e observe o total.
package main
import "fmt"
func worker(id int, jobs <-chan int, results chan<- int) {
for j := range jobs {
results <- j * 2
}
}
func main() {
jobs := make(chan int, 5)
results := make(chan int, 5)
for w := 1; w <= 3; w++ {
go worker(w, jobs, results)
}
for j := 1; j <= 5; j++ {
jobs <- j
}
close(jobs)
total := 0
for a := 1; a <= 5; a++ {
total += <-results
}
fmt.Println("total:", total)
}Com buffer versus sem buffer
Um canal de tarefas com buffer permite que o produtor enfileire trabalho sem bloquear até o preenchimento do buffer. Um canal sem buffer força uma transferência: o envio bloqueia até que um processo worker esteja pronto. O buffer suaviza produtores com picos de atividade.
Escolhendo o tamanho do pool
Para trabalho limitado pela CPU, dimensione o pool próximo de runtime.NumCPU(). Para trabalho limitado por IO, como rede ou disco, você pode usar um número muito maior, pois os processos worker passam tempo esperando, e não calculando.
package main
import (
"fmt"
"runtime"
)
func main() {
fmt.Println("CPUs:", runtime.NumCPU())
}Evitando vazamentos de gorrotinas
Se você esquecer de close(jobs), os processos worker ficarão bloqueados para sempre em um canal vazio e haverá um vazamento. Sempre feche o canal de tarefas assim que todo o trabalho for enviado, para que os laços for range terminem.
Verificação rápida
Avalie seu entendimento sobre pools de workers.
Recapitulação
Você aprendeu o padrão de pool de workers:
- Inicie um número fixo de workers que leem de um canal compartilhado de tarefas
- Use tipos direcionais de canal para garantir segurança
- Feche o canal de tarefas para encerrar os workers
- Reúna os resultados para sincronizar a conclusão
- Dimensione o pool de acordo com o tipo de carga de trabalho (CPU ou IO)
Perguntas Frequentes
A aula “Padrão de pool de trabalhadores” é grátis?
Sim — o texto completo de “Padrão de pool de trabalhadores” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.
O que vou aprender em “Padrão de pool de trabalhadores”?
Limite a simultaneidade Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Go Academy?
Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Padrão de pool de trabalhadores”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Go Academy?
Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Padrão de pool de trabalhadores
- Fan-out e fan-in
- Estágios do pipeline
- Desligamento normal