sync.WaitGroup

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy — lección 64 de 107.

En la lección de Conceptos Básicos de Goroutines, usamos time.Sleep para esperar a que las goroutines terminen —un enfoque frágil. sync.WaitGroup proporciona una forma adecuada de esperar a que una colección de goroutines complete su trabajo.

Un WaitGroup funciona como un contador. Lo incrementas antes de iniciar una goroutine, lo decrementas cuando la goroutine termina y bloqueas hasta que el contador llega a cero:

func main() {
    var wg sync.WaitGroup
    
    for i := 1; i <= 3; i++ {
        wg.Add(1)  // incrementar el contador
        go func(id int) {
            defer wg.Done()  // decrementar al terminar
            fmt.Printf("Worker %d finished\n", id)
        }(i)
    }
    
    wg.Wait()  // bloquear hasta que el contador sea 0
    fmt.Println("All workers complete")
}

Los tres métodos clave son Add(n) para aumentar el contador en n, Done() para disminuirlo en uno (equivalente a Add(-1)), y Wait() para bloquear hasta que el contador llegue a cero. El uso de defer wg.Done() asegura que el contador decremente incluso si la goroutine entra en pánico.

Un error común es llamar a Add dentro de la goroutine en lugar de antes de ella. Esto crea una condición de carrera donde Wait podría retornar antes de que todas las goroutines estén registradas:

// Incorrecto - condición de carrera
go func() {
    wg.Add(1)  // podría ejecutarse después de Wait()
    defer wg.Done()
}()

// Correcto - Añadir antes de lanzar
wg.Add(1)
go func() {
    defer wg.Done()
}()

Los WaitGroups a menudo se incrustan en structs para coordinar operaciones concurrentes, lo que los hace esenciales para construir tipos seguros para hilos (thread-safe) en Go.

Desafío

Fácil

Vamos a construir un gestor de descargas que coordine múltiples descargas de archivos concurrentes utilizando sync.WaitGroup. Tu gestor rastreará cuándo se completan todas las descargas sin depender de temporizadores de espera arbitrarios.

Organizarás tu código en dos archivos:

downloader.go: Define tu lógica de coordinación de descargas.
Crea un struct Download con los campos ID (int), Filename (string) y Size (int, que representa KB).

Implementa un método Process(wg *sync.WaitGroup) en Download que simule la descarga durmiendo durante un tiempo basado en el tamaño del archivo (usa Size * 10 milisegundos). Cuando la descarga se complete, imprime: Downloaded: [Filename] ([Size]KB). Usa defer wg.Done() para asegurar que el contador del WaitGroup se decremente correctamente.

Crea una función StartDownloads(downloads []Download) int que inicie todas las descargas de forma concurrente utilizando goroutines y espere a que todas se completen. Recuerda llamar a wg.Add(1) antes de lanzar cada goroutine, no dentro de ella. Devuelve el tamaño total de todas las descargas combinadas.
main.go: Lee la información de las descargas y orquestas las descargas concurrentes.
Lee el número de descargas, luego, para cada descarga, lee su ID, nombre de archivo y tamaño. Crea las descargas y pásalas a StartDownloads. Después de que todas las descargas se completen, imprime: All downloads complete: [total]KB total

Se proporcionarán las siguientes entradas:

Línea 1: Número de descargas (entero)
Líneas siguientes: Para cada descarga, tres líneas - el ID (entero), el nombre del archivo (string) y el tamaño en KB (entero)

Por ejemplo, dado:

3
1
report.pdf
20
2
image.png
5
3
data.csv
10

Tu salida debería mostrar las descargas completándose (los archivos más pequeños terminan primero debido a tiempos de espera más cortos), seguido del resumen:

Downloaded: image.png (5KB)
Downloaded: data.csv (10KB)
Downloaded: report.pdf (20KB)
All downloads complete: 35KB total

La diferencia clave con el uso de time.Sleep es que wg.Wait() se bloquea hasta que todas las goroutines señalan su finalización con Done(), lo que te proporciona una sincronización precisa independientemente de cuánto tiempo tarde cada descarga.

Hoja de referencia

Un sync.WaitGroup proporciona una forma adecuada de esperar a que las goroutines se completen. Funciona como un contador que rastrea las goroutines en ejecución.

Los tres métodos clave son:

Add(n) - incrementa el contador en n
Done() - decrementa el contador en uno (equivalente a Add(-1))
Wait() - bloquea hasta que el contador llega a cero

Patrón de uso básico:

var wg sync.WaitGroup

for i := 1; i <= 3; i++ {
    wg.Add(1)  // increment before starting goroutine
    go func(id int) {
        defer wg.Done()  // decrement when done
        fmt.Printf("Worker %d finished\n", id)
    }(i)
}

wg.Wait()  // block until all goroutines complete
fmt.Println("All workers complete")

El uso de defer wg.Done() asegura que el contador se decremente incluso si la goroutine entra en pánico.

Importante: Siempre llame a Add antes de lanzar la goroutine, no dentro de ella, para evitar condiciones de carrera:

// Wrong - race condition
go func() {
    wg.Add(1)  // might run after Wait()
    defer wg.Done()
}()

// Correct
wg.Add(1)
go func() {
    defer wg.Done()
}()

Pruébalo tú mismo

package main

import (
	"fmt"
)

func main() {
	// Leer el número de descargas
	var n int
	fmt.Scanln(&n)

	// Leer la información de las descargas
	downloads := make([]Download, n)
	for i := 0; i < n; i++ {
		var id int
		var filename string
		var size int
		fmt.Scanln(&id)
		fmt.Scanln(&filename)
		fmt.Scanln(&size)
		
		downloads[i] = Download{
			ID:       id,
			Filename: filename,
			Size:     size,
		}
	}

	// TODO: Llamar a StartDownloads con el slice de descargas
	// TODO: Imprimir el resumen: "All downloads complete: [total]KB total"
}