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 Fundamentos de las goroutines, usamos time.Sleep para esperar a que las goroutines terminaran: 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)  // incrementa el contador
        go func(id int) {
            defer wg.Done()  // decrementa al terminar
            fmt.Printf("Worker %d finished\n", id)
        }(i)
    }
    
    wg.Wait()  // bloquea hasta que el contador sea 0
    fmt.Println("All workers complete")
}

Los tres métodos principales son Add(n) para aumentar el contador en n, Done() para disminuirlo en uno (equivalente a Add(-1)), y Wait() para bloquearse hasta que el contador llegue a cero. Usar defer wg.Done() garantiza que el contador disminuya incluso si la goroutine entra en pánico.

Un error común es llamar a Add dentro de la gorutina en lugar de hacerlo antes. Esto crea una condición de carrera en la que Wait podría devolver el control antes de que todas las gorutinas estén registradas:

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

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

Los WaitGroups suelen estar integrados en estructuras para coordinar operaciones simultáneas, lo que los hace esenciales para crear tipos seguros para subprocesos en Go.

Desafío

Fácil

Construyamos un gestor de descargas que coordine varias descargas de archivos simultáneas mediante sync.WaitGroup. Tu gestor hará un seguimiento de 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 la lógica de coordinación de tus descargas.
Crea una estructura Download con 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 se complete la descarga, imprime: Downloaded: [Filename] ([Size]KB). Usa defer wg.Done() para asegurarte de que el contador de WaitGroup disminuya correctamente.

Crea una función StartDownloads(downloads []Download) int que inicie todas las descargas simultáneamente mediante goroutines y espere a que todas se completen. Recuerda llamar a wg.Add(1) antes de iniciar cada goroutine, no dentro de ella. Devuelve el tamaño total combinado de todas las descargas.
main.go: Lee la información de las descargas y coordina las descargas simultáneas.
Lee el número de descargas y, después, para cada descarga, lee su ID, nombre de archivo y tamaño. Crea las descargas y pásalas a StartDownloads. Después de que se completen todas las descargas, 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 de archivo (cadena) y el tamaño en KB (entero)

Por ejemplo, dada la siguiente entrada:

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

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

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

La diferencia clave respecto a usar time.Sleep es que wg.Wait() se bloquea hasta que todas las goroutines señalan que han terminado mediante Done(), lo que te proporciona una sincronización precisa independientemente de cuánto tarde cada descarga.

Pruébalo tú mismo

package main

import (
	"fmt"
)

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

	// Lee la información de descarga
	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: Llama a StartDownloads con el slice downloads
	// TODO: Print the summary: "All downloads complete: [total]KB total"
}