Boas Práticas Fundamentais de Concorrência

Compartilhe memória comunicando - e quando usar locks.

Estas regras mantêm as goroutines limitadas, os canais livres de deadlock e o estado compartilhado livre de race conditions, desde os laptops de desenvolvimento até os serviços de produção.

Como Usar Esta Lista

• Aplique durante a revisão de código em qualquer PR que adicione go, canais ou tipos sync.
• Execute go test -race ./... e golangci-lint nos pacotes tocados antes de mesclar.
• Quando uma regra conflitar com dados de benchmark, documente a exceção com um link de perfil.
• Revise após atualizações do Go; a semântica do scheduler e dos loops evolui entre as versões.

A - Goroutines e ciclo de vida

• Saiba como o trabalho termina antes de iniciá-lo. Cada go precisa de um caminho para a conclusão: WaitGroup, close(ch) ou cancelamento de context.
• Nunca deixe main retornar enquanto os workers ainda estiverem em execução. A saída mata o processo sem esperar pelas goroutines em segundo plano.
• Limite o fan-out para entradas grandes. Use pools de workers em vez de uma goroutine por linha, requisição ou arquivo.
• Passe variáveis de loop para parâmetros de goroutine. Defensivo em todas as versões suportadas do Go; documenta a intenção em bibliotecas.
• Monitore runtime.NumGoroutine() em testes de longa duração (soak tests). O crescimento monotônico sinaliza vazamentos em recebimentos de canal bloqueados.

B - Canais e select

• Use canais não bufferizados por padrão para semântica de passagem de controle. Adicione buffer apenas quando os perfis mostrarem assimetria entre produtor e consumidor.
• Apenas remetentes fecham canais. Receptores detectam o desligamento com range ou v, ok := <-ch.
• Nunca envie em um canal fechado. Proteja os fechadores compartilhados com sync.Once ou uma goroutine coordenadora dedicada.
• Evite loops de spin com select + default. Busy polls consomem CPU; bloqueie ou use tickers/deadlines de contexto.
• Prefira context.WithTimeout em vez de time.After em loops de servidor. Reutilize timers em caminhos de alta performance para reduzir alocações.

C - Mutexes, atômicos e estado compartilhado

• Proteja mapas e slices que são mutados por múltiplas goroutines. Mapas nativos não são seguros para concorrência sem sincronização.
• Use defer mu.Unlock() imediatamente após Lock. Sobrevive a panics e retornos antecipados em manipuladores.
• Escolha uma ordem de lock quando múltiplos mutexes interagem. Documente a ordem nos comentários do tipo para prevenir deadlocks.
• Mantenha locks por microssegundos, não milissegundos. Copie os dados para fora, libere e, em seguida, realize I/O ou RPC sem lock.
• Use atômicos apenas para contadores/flags simples. Invariantes de múltiplos campos ainda precisam de mutexes.

D - Testes, detector de race e produção

• Execute go test -race em CI para pacotes que usam concorrência. Trate novos relatórios de race como bloqueadores de lançamento.
• Estresse testes instáveis com -count=50 -race. Intercalações expõem races que passam uma vez.
• Não envie binários com -race para produção sensível à latência. Use testes de longa duração em staging com builds de race em vez disso.
• Instale recuperação de pânico nas fronteiras HTTP/gRPC. chi, gin, echo e interceptadores gRPC capturam panics por requisição.
• Propague context.Context através de árvores de chamadas concorrentes. O cancelamento para goroutines downstream quando os clientes se desconectam.

FAQs

Relacionados

• Concorrência em Go: Goroutines e Canais Primeiro - visão geral da seção
• Fundamentos de Concorrência - exemplos introdutórios executáveis
• Canais: Regras de Buffer, Sem Buffer e Fechamento - semântica de fechamento
• Detector de Race: Executando e Interpretando Saída - fluxo de trabalho de race em CI
• sync.Mutex, RWMutex e WaitGroup - disciplina de lock

Versões da Stack: Esta página foi escrita para Go 1.26.x (padrão Green Tea GC, go fix modernizers - verifique o patch na compilação), chi (latest - verifique na compilação), gin (latest - verifique na compilação), echo (latest - verifique na compilação), google.golang.org/grpc (latest - verifique na compilação), sigs.k8s.io/controller-runtime (latest - verifique na compilação), kubebuilder (latest - verifique na compilação), tinygo (latest - verifique os alvos de placa na compilação), wazero (latest - verifique na compilação) e golangci-lint (latest - verifique o conjunto de linters na compilação).