Variável de Loop & Bugs de Fechamento de Goroutine

Você inicia dez goroutines em um loop e todas imprimem 10 em vez de 0 a 9.

Esta página explica a captura de variáveis de loop, o que o Go 1.22 mudou e os padrões defensivos que ainda importam para defer, closures aninhados e bibliotecas que visam versões mais antigas do Go.

Resumo

Um closure captura variáveis por referência, não por um snapshot de iteração de loop.

Antes do Go 1.22, a única variável de valor i do loop for ou range era reutilizada a cada iteração, então as goroutines iniciadas no loop frequentemente observavam o valor final.

Go 1.22+ cria uma nova variável por iteração para for e range, corrigindo o caso comum, mas defer dentro de loops, closures manuais de variáveis externas e código compilado com diretivas go mais antigas ainda exigem cópias explícitas.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

// Defensivo (todas as versões): copiar antes da goroutine
for _, item := range items {
    item := item
    go func() {
        process(item)
    }()
}
 
// Go 1.22+ vars por iteração (padrão com go 1.22 em go.mod)
for i := range n {
    go func() {
        process(i) // cada goroutine recebe seu próprio i
    }()
}
 
// Passar como parâmetro (mais claro)
for _, item := range items {
    go func(it Item) {
        process(it)
    }(item)
}

Quando usar isso:

• Iniciar goroutines dentro de qualquer loop
• errgroup ou pools de workers sobre uma coleção
• Testes de tabela com t.Parallel() dentro de um range
• Agendar callbacks que fecham sobre variáveis de loop
• Manter bibliotecas que devem compilar no Go 1.21 ou anterior

Exemplo de Trabalho

package main
 
import (
    "fmt"
    "sync"
)
 
func buggy(ids []int) {
    var wg sync.WaitGroup
    for _, id := range ids {
        wg.Add(1)
        go func() {
            defer wg.Done()
            fmt.Println("buggy", id) // pode imprimir apenas o último id com a semântica pré-1.22
        }()
    }
    wg.Wait()
}
 
func fixed(ids []int) {
    var wg sync.WaitGroup
    for _, id := range ids {
        wg.Add(1)
        id := id
        go func() {
            defer wg.Done()
            fmt.Println("fixed", id)
        }()
    }
    wg.Wait()
}
 
func main() {
    ids := []int{1, 2, 3}
    buggy(ids)
    fixed(ids)
}

O que isso demonstra:

• O closure captura id pela referência ao endereço da variável do loop
• id := id cria uma ligação por iteração segura para a goroutine
• Passar parâmetros go func(id int) { ... }(item) documenta a intenção na revisão de código
• Sempre Wait() ou use errgroup para que o main não saia antes que as goroutines executem

Mergulho Profundo

Como Funciona

• Variáveis de loop vivem para toda a instrução do loop, não por iteração (pré-1.22)
• O agendamento de goroutines significa que o loop pode terminar antes que os filhos executem, deixando apenas o valor final
• Notas de lançamento do Go 1.22: variáveis de loop por iteração para for e range sob a versão de linguagem go 1.22
• defer em um loop ainda empilha defers até que a função retorne, não por iteração

Versão e Ferramentas

Notas do Go

// defer em loop: RUIM - todos os defers rodam na saída da função
for _, f := range files {
    defer f.Close()
}
 
// BOM - função com escopo por iteração
for _, f := range files {
    func() {
        defer f.Close()
        // trabalhar com f
    }()
}

Armadilhas

• Assumir que Go 1.22 corrigiu todos os bugs de closure - Variáveis externas de escopos envolventes ainda são aliases. Correção: copiar qualquer coisa mutável que o closure leia.
• defer em loops - Defers se acumulam; arquivos permanecem abertos até o final da função. Correção: função aninhada por iteração.
• Testes de tabela com subtestes paralelos - t.Run(tc.name, func(t *testing.T) { t.Parallel(); use(tc) }) precisa de tc := tc. Correção: copiar antes de t.Run.
• Pools de workers lendo o índice do loop - Goroutines do pool podem rodar após o loop completar. Correção: passar o índice como campo da tarefa.
• Bibliotecas sem atualização de versão do go.mod - Consumidores no 1.22 ainda veem o comportamento antigo se a biblioteca definir uma linguagem mais antiga. Correção: cópia defensiva no código da biblioteca.
• Closures em manipuladores HTTP registrando callbacks - O registro fecha sobre a variável do loop da configuração. Correção: passar parâmetros no momento do registro.

Alternativas

FAQs

Relacionados

• Debugging Go: Falhas Observáveis e Pontos Críticos - família de sintomas de closure
• Vazamentos de Goroutine & Cancelamento de Contexto Perdido - vazamentos de defer-em-loop
• Cenários de Data Race & Correções do Race Detector - races com estado de loop compartilhado
• Variantes de Loop for & Semântica de range - formas de range
• Melhores Práticas de Fluxo de Controle - regras de loop e goroutine

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

WTI5a1pXZDFhV1JsY3k1cGIzeGpaMmx2TkRZNGZESXdNall3Tnc9PQ==