Go Academy · Lección

sync.WaitGroup

Espera de un conjunto de goroutines

sync.WaitGroup es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

Propósito

sync.WaitGroup espera a que termine un conjunto de goroutines. La goroutine principal llama a Add para establecer el contador, cada goroutine llama a Done cuando termina y Wait se bloquea hasta que el contador llega a cero.

Uso básico

Llame a Add antes de iniciar cada goroutine, a Done al final de cada goroutine (mediante defer) y a Wait después de iniciar todas las goroutines.

var wg sync.WaitGroup
for _, item := range items {
    wg.Add(1)
    go func(v Item) {
        defer wg.Done()
        process(v)
    }(item)
}
wg.Wait()

Add debe ejecutarse antes de iniciar la goroutine

Llame a wg.Add(1) antes de go func(), nunca dentro de la goroutine. De lo contrario, Wait podría devolver el control antes de que la goroutine se registre.

Error común: captura de la variable de bucle

Transfiera la variable de bucle como argumento a la función de la goroutine, en lugar de hacerlo mediante un cierre, para evitar que todas las goroutines compartan la misma variable.

for _, v := range items {
    wg.Add(1)
    go func(item Item) { // correct: copy
        defer wg.Done()
        process(item)
    }(v)
}

Reutilización de un WaitGroup

Puede reutilizar un WaitGroup después de que Wait devuelva el control, pero solo si todas las llamadas anteriores a Done han terminado. No lo reutilice mientras haya llamadas a Done pendientes.

WaitGroup con resultados

WaitGroup no recopila resultados; combínelo con un canal o con un slice (protegido con un mutex) para recopilar la salida de las goroutines.

results := make([]Result, len(items))
for i, item := range items {
    wg.Add(1)
    go func(idx int, v Item) {
        defer wg.Done()
        results[idx] = process(v)
    }(i, item)
}
wg.Wait()

Add con cantidad por lote

Puede pasar la cantidad total a una sola llamada a Add antes del bucle, lo que es ligeramente más eficiente que llamar a Add una vez por goroutine.

wg.Add(len(items))
for _, item := range items {
    go func(v Item) { defer wg.Done(); process(v) }(item)
}

No copie un WaitGroup

Al igual que Mutex, no debe copiar un WaitGroup después de su primer uso. Páselo mediante un puntero o inclúyalo en una estructura que se pase mediante un puntero.

WaitGroup frente a errgroup

golang.org/x/sync/errgroup encapsula WaitGroup y añade la propagación de errores. Prefiera errgroup cuando un fallo de cualquier goroutine deba detener las demás.

Combinación con context

Utilice errgroup.WithContext para obtener tanto la semántica de WaitGroup como un contexto que se cancela ante el primer error y detiene correctamente todas las goroutines.

g, ctx := errgroup.WithContext(context.Background())
g.Go(func() error { return doWork(ctx) })
if err := g.Wait(); err != nil { log.Fatal(err) }

El valor cero se puede utilizar

El valor cero de sync.WaitGroup está listo para usarse; no se necesita ningún constructor. Solo debe declararlo y llamar a Add.

Comprobación rápida

¿Qué ocurre si llama a wg.Add(1) dentro de la goroutine en lugar de hacerlo antes de iniciarla?

Repaso: sync.WaitGroup

Puntos clave:

Add antes de iniciar la goroutine; Done mediante defer dentro de la goroutine
Wait se bloquea hasta que el contador llega a cero
Nunca lo copie; nunca llame a Add dentro de la goroutine
Utilice errgroup para propagar errores

Preguntas frecuentes

¿La lección «sync.WaitGroup» es gratis?

Sí — el texto completo de «sync.WaitGroup» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «sync.WaitGroup»?

Espera de un conjunto de goroutines Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «sync.WaitGroup»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Go Academy