sync.WaitGroup

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy. Lição 64 de 107.

Na lição Fundamentos de Goroutines, usamos time.Sleep para esperar que as goroutines terminassem: uma abordagem frágil. sync.WaitGroup oferece uma maneira adequada de esperar que uma coleção de goroutines conclua seu trabalho.

Um WaitGroup funciona como um contador. Você o incrementa antes de iniciar uma goroutine, o decrementa quando a goroutine termina e bloqueia até que o contador chegue a zero:

func main() {
    var wg sync.WaitGroup
    
    for i := 1; i <= 3; i++ {
        wg.Add(1)  // incrementa o contador
        go func(id int) {
            defer wg.Done()  // decrementa quando terminar
            fmt.Printf("Worker %d finished\n", id)
        }(i)
    }
    
    wg.Wait()  // bloqueia até o contador ser 0
    fmt.Println("All workers complete")
}

Os três métodos principais são Add(n) para aumentar o contador em n, Done() para diminuí-lo em um (equivalente a Add(-1)) e Wait() para bloquear até que o contador chegue a zero. Usar defer wg.Done() garante que o contador seja decrementado mesmo que a goroutine entre em pânico.

Um erro comum é chamar Add dentro da goroutine em vez de antes dela. Isso cria uma condição de corrida na qual Wait pode retornar antes que todas as goroutines sejam registradas:

// Errado - condição de corrida
go func() {
    wg.Add(1)  // pode executar depois de Wait()
    defer wg.Done()
}()

// Correto - Add antes de lançar
wg.Add(1)
go func() {
    defer wg.Done()
}()

WaitGroups geralmente são incorporados a estruturas para coordenar operações concorrentes, tornando-os essenciais para criar tipos seguros para uso em threads no Go.

Desafio

Fácil

Vamos criar um gerenciador de downloads que coordene vários downloads de arquivos simultâneos usando sync.WaitGroup. Seu gerenciador acompanhará quando todos os downloads forem concluídos sem depender de temporizadores de espera arbitrários.

Você organizará seu código em dois arquivos:

downloader.go: Defina sua lógica de coordenação dos downloads.
Crie uma struct Download com os campos ID (int), Filename (string) e Size (int, representando KB).

Implemente um método Process(wg *sync.WaitGroup) em Download que simule o download dormindo por uma duração baseada no tamanho do arquivo (use Size * 10 milissegundos). Quando o download for concluído, imprima: Downloaded: [Filename] ([Size]KB). Use defer wg.Done() para garantir que o contador de WaitGroup seja decrementado corretamente.

Crie uma função StartDownloads(downloads []Download) int que inicie todos os downloads simultaneamente usando goroutines e aguarde a conclusão de todos eles. Lembre-se de chamar wg.Add(1) antes de iniciar cada goroutine, não dentro dela. Retorne o tamanho total combinado de todos os downloads.
main.go: Leia as informações dos downloads e coordene os downloads simultâneos.
Leia o número de downloads e, em seguida, para cada download, leia seu ID, nome do arquivo e tamanho. Crie os downloads e passe-os para StartDownloads. Depois que todos os downloads forem concluídos, imprima: All downloads complete: [total]KB total

As seguintes entradas serão fornecidas:

Linha 1: Número de downloads (inteiro)
Linhas seguintes: Para cada download, três linhas — o ID (inteiro), o nome do arquivo (string) e o tamanho em KB (inteiro)

Por exemplo, considerando:

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

Sua saída deve mostrar os downloads sendo concluídos (arquivos menores terminam primeiro devido aos tempos de espera mais curtos), seguidos pelo resumo:

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

A principal diferença em relação ao uso de time.Sleep é que wg.Wait() bloqueia até que todas as goroutines sinalizem a conclusão com Done(), proporcionando uma sincronização precisa, independentemente de quanto tempo cada download leve.

Experimente você mesmo

package main

import (
	"fmt"
)

func main() {
	// Ler o número de downloads
	var n int
	fmt.Scanln(&n)

	// Ler informações de download
	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: Chamar StartDownloads com o slice downloads
	// TODO: Print the summary: "All downloads complete: [total]KB total"
}