Go Academy · Aula

Padrão de pool de workers

Crie um pool de workers com um número fixo de goroutines

Padrão de pool de workers é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 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 conjunto de trabalhadores?

Um conjunto de trabalhadores pré-cria um número fixo de gorrotinas que processam tarefas de uma fila compartilhada. Isso limita a concorrência e evita o esgotamento de recursos causado pela criação ilimitada de gorrotinas.

Implementação básica

Crie um canal de tarefas e N gorrotinas que leiam dele:

func workerPool(n int, jobs <-chan Job, results chan<- Result) {
    var wg sync.WaitGroup
    for i := 0; i < n; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                results <- process(job)
            }
        }()
    }
    wg.Wait()
    close(results)
}

Enviando tarefas

Envie todas as tarefas para o canal e depois feche-o. Os trabalhadores processarão todas as tarefas e sairão dos laços de iteração quando o canal for fechado.

jobs := make(chan Job, 100)
for _, j := range allJobs {
    jobs <- j
}
close(jobs) // signals workers to stop after draining

Coletando resultados

Leia os resultados simultaneamente ao envio das tarefas. Use uma gorrotina para o conjunto, para que a coleta de resultados não cause um interbloqueio com o envio das tarefas.

results := make(chan Result, 100)
go workerPool(5, jobs, results)
for r := range results {
    collect(r)
}

Ajustando o tamanho do conjunto

Para trabalhos limitados pela CPU, defina o tamanho do conjunto como runtime.NumCPU(). Para trabalhos limitados por E/S, um multiplicador maior (por exemplo, 10×) aproveita melhor o tempo de espera. Analise o desempenho para encontrar o ponto ideal.

n := runtime.NumCPU()
if ioHeavy { n = runtime.NumCPU() * 10 }

Adicionando o cancelamento de contexto

Passe um contexto aos trabalhadores para que eles parem mais cedo quando houver cancelamento:

for {
    select {
    case job, ok := <-jobs:
        if !ok { return }
        results <- process(ctx, job)
    case <-ctx.Done():
        return
    }
}

Alternativa com semáforo

Em vez de um conjunto fixo de gorrotinas, use um canal com buffer como semáforo para limitar o número de gorrotinas executadas simultaneamente, continuando a iniciar uma por tarefa.

sem := make(chan struct{}, 10)
for _, job := range jobs {
    sem <- struct{}{}
    go func(j Job) {
        defer func() { <-sem }()
        process(j)
    }(job)
}

Tratamento de erros

Retorne os erros junto com os resultados usando uma estrutura de resultado. Cancele o contexto no primeiro erro ou colete todos os erros para um relatório final.

type Result struct{ Val int; Err error }

Dimensionamento dinâmico do conjunto

Para conjuntos adaptáveis, use golang.org/x/sync/semaphore, que permite adquirir e liberar um recurso ponderado e oferece limites dinâmicos de concorrência.

Conjunto de trabalhadores versus grupo de erros

golang.org/x/sync/errgroup fornece uma API mais simples para iniciar N gorrotinas e coletar o primeiro erro. Use um conjunto quando precisar de um grupo persistente de trabalhadores reutilizáveis.

Encerramento organizado

Feche o canal de tarefas para sinalizar aos trabalhadores. Depois que o WaitGroup terminar, feche os resultados. Qualquer envio de tarefa pendente deve ocorrer antes de close(jobs).

Verificação rápida

Como um conjunto de trabalhadores sinaliza aos trabalhadores que parem de processar?

Recapitulação: conjunto de trabalhadores

Pontos principais:

N gorrotinas fixas leem de um canal de tarefas
feche o canal de tarefas para sinalizar aos trabalhadores que terminem
WaitGroup acompanha a conclusão; feche os resultados quando terminar
trabalho limitado pela CPU: tamanho do conjunto ≈ NumCPU; trabalho limitado por E/S: maior

Perguntas Frequentes

A aula “Padrão de pool de workers” é grátis?

Sim — o texto completo de “Padrão de pool de workers” é 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 workers”?

Crie um pool de workers com um número fixo de goroutines 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 4 de 4.

Quanto tempo leva a aula “Padrão de pool de workers”?

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

← Voltar para Go Academy