Errores de Variables de Bucle y Cierre de Goroutines

Lanzas diez goroutines en un bucle y cada una imprime 10 en lugar de 0 a 9.

Esta página explica la captura de variables de bucle, qué cambió Go 1.22 y los patrones defensivos que aún importan para defer, cierres anidados y bibliotecas dirigidas a versiones anteriores de Go.

Resumen

Un cierre captura variables por referencia, no por instantánea de iteración del bucle.

Antes de Go 1.22, la única variable de valor i o range del bucle for se reutilizaba en cada iteración, por lo que las goroutines iniciadas en el bucle a menudo observaban el valor final.

Go 1.22+ crea una nueva variable por iteración para for y range, corrigiendo el caso común, pero defer dentro de bucles, cierres manuales de variables externas y código compilado con directivas go más antiguas aún requieren copias explícitas.

Receta

Tarjeta de receta de referencia rápida, lista para copiar y pegar.

// Defensivo (todas las versiones): copiar antes de la goroutine
for _, item := range items {
    item := item
    go func() {
        process(item)
    }()
}
 
// Variables por iteración de Go 1.22+ (predeterminado con go 1.22 en go.mod)
for i := range n {
    go func() {
        process(i) // cada goroutine obtiene su propia i
    }()
}
 
// Pasar como parámetro (más claro)
for _, item := range items {
    go func(it Item) {
        process(it)
    }(item)
}

Cuándo usar esto:

• Iniciar goroutines dentro de cualquier bucle
• errgroup o pools de trabajadores sobre una colección
• Pruebas de tabla con t.Parallel() dentro de range
• Programar callbacks que cierran sobre variables de bucle
• Mantener bibliotecas que deben compilarse en Go 1.21 o versiones anteriores

Ejemplo de Trabajo

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) // puede imprimir solo el último id con la semántica pre-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)
}

Lo que esto demuestra:

• El cierre captura id por referencia a la dirección de la variable del bucle
• id := id crea una vinculación por iteración segura para la goroutine
• Pasar parámetros go func(id int) { ... }(item) documenta la intención en la revisión del código
• Siempre Wait() o usa errgroup para que main no salga antes de que se ejecuten las goroutines

Análisis Profundo

Cómo Funciona

• Las variables de bucle viven durante toda la declaración del bucle, no por iteración (pre-1.22)
• La programación de goroutines significa que el bucle puede terminar antes de que se ejecuten los hijos, dejando solo el valor final
• Notas de la versión de Go 1.22: variables de bucle por iteración para for y range bajo la versión de lenguaje go 1.22
• defer en un bucle todavía apila los defer hasta que la función retorna, no por iteración

Versión y Herramientas

Notas de Go

// defer en bucle: MALO - todos los defer se ejecutan al final de la función
for _, f := range files {
    defer f.Close()
}
 
// BUENO - función con ámbito por iteración
for _, f := range files {
    func() {
        defer f.Close()
        // trabajar con f
    }()
}

Trampas

• Asumir que Go 1.22 corrigió todos los errores de cierre - Las variables externas de los ámbitos circundantes todavía se aliásan. Corrección: copiar cualquier cosa mutable que el cierre lea.
• defer en bucles - Los defer se acumulan; los archivos permanecen abiertos hasta el final de la función. Corrección: función anidada por iteración.
• Pruebas de tabla con subpruebas paralelas - t.Run(tc.name, func(t *testing.T) { t.Parallel(); use(tc) }) necesita tc := tc. Corrección: copiar antes de t.Run.
• Pools de trabajadores leyendo el índice del bucle - Las goroutines del pool pueden ejecutarse después de que el bucle se complete. Corrección: pasar el índice como campo de tarea.
• Bibliotecas sin actualización de versión de go.mod - Los consumidores en 1.22 aún ven el comportamiento antiguo si la biblioteca establece un lenguaje anterior. Corrección: copia defensiva en el código de la biblioteca.
• Cierres en manejadores HTTP que registran callbacks - El registro cierra sobre la variable del bucle desde la configuración. Corrección: pasar parámetros en el momento del registro.

Alternativas

Preguntas Frecuentes

Relacionado

• Depuración de Go: Fallos Observables y Bordes Afilados - familia de síntomas de cierre
• Fugas de Goroutines y Cancelación de Contexto Perdida - fugas de defer en bucle
• Escenarios de Carreras de Datos y Correcciones del Detector de Carreras - carreras con estado de bucle compartido
• Variantes de Bucles for y Semántica de range - formas de range
• Mejores Prácticas de Flujo de Control - reglas de bucle y goroutine

Versiones de Stack: Esta página fue escrita para Go 1.26.x (GC predeterminado Green Tea, go fix modernizers - verificar parche en la compilación), chi (última - verificar en la compilación), gin (última - verificar en la compilación), echo (última - verificar en la compilación), google.golang.org/grpc (última - verificar en la compilación), sigs.k8s.io/controller-runtime (última - verificar en la compilación), kubebuilder (última - verificar en la compilación), tinygo (última - verificar objetivos de placa en la compilación), wazero (última - verificar en la compilación) y golangci-lint (última - verificar conjunto de linters en la compilación).

WTI5a1pXZDFhV1JsY3k1cGIzeGpaMmx2TkRZNGZESXdNall3Tnc9PQ==