Concorrência Prática: Worker Pools

jobs := make(chan int, len(values))
for index := range values { jobs <- index } // Cada job leva o destino.
close(jobs)
results := make([]int, len(values))
var group sync.WaitGroup
group.Add(workers)
for range workers {
	go func() {
		defer group.Done()
		for index := range jobs { results[index] = values[index] * values[index] } // Índice fixa a ordem.
	}()
}
group.Wait() // Barreira antes de ler results.

Uma cozinha recebe comandas numeradas: 17, 18 e 19. Dois cozinheiros podem preparar pratos em paralelo, mas o garçom precisa entregar cada prato à mesa indicada, não à primeira mesa livre. O número da comanda é o dado que permite separar ordem de execução de ordem do resultado. Goroutines são os cozinheiros; o índice do slice é a comanda.

Iniciar uma função com go apenas autoriza execução concorrente. Não garante que ela comece antes da próxima linha, não faz main esperá-la e não protege variáveis compartilhadas. Se duas goroutines executam total += value, a operação de leitura, soma e escrita pode se intercalar: isso é uma data race, acesso concorrente incompatível ao mesmo estado.

Um channel cria um ponto de encontro. Em um channel sem buffer, o envio só termina quando algum receptor aceita o valor. close(jobs) acrescenta outro sinal: não haverá novas comandas. Workers usam range jobs e saem quando a fila foi fechada e drenada. O fechamento não espera o cálculo atual terminar, por isso o programa ainda precisa de sync.WaitGroup como barreira final.

Para resultados independentes, pré-alocamos results e fazemos cada job carregar index. Dois workers podem concluir em qualquer ordem, mas nunca escrevem na mesma posição. Para uma redução, como soma, damos um acumulador exclusivo a cada worker e combinamos as parciais somente depois de Wait. Nos dois desenhos, a sincronização segue fatos observáveis, não uma estimativa de duração.

O teste de sanidade é trocar dois por oito workers e repetir a entrada. A distribuição interna provavelmente muda; [4 9 16] e o total 29 não. Quando a API devolve o mesmo resultado sob todos os escalonamentos válidos, a concorrência deixou de vazar para o contrato.

Antes de rodar, some mentalmente os quadrados: o resultado deve ser 56, embora a ordem em que chegam a out não seja contratada. O fechamento acontece numa goroutine separada porque main precisa continuar recebendo; se chamasse group.Wait() antes do range, workers poderiam bloquear tentando enviar e ninguém os drenaria.

package main

import (
	"fmt"
	"sync"
)

func main() {
	values := []int{2, 4, 6}
	out := make(chan int)
	var group sync.WaitGroup
	for _, value := range values {
		group.Add(1)
		go func(n int) {
			defer group.Done()
			out <- n * n
		}(value)
	}
	go func() {
		group.Wait()
		close(out)
	}()
	total := 0
	for square := range out {
		total += square
	}
	fmt.Println(total)
}