Go Academy · Aula

sync.WaitGroup

Aguarde uma coleção de goroutines

sync.WaitGroup é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Finalidade

sync.WaitGroup aguarda uma coleção de goroutines terminar. A goroutine principal chama Add para definir a contagem, cada goroutine chama Done ao concluir, e Wait bloqueia até a contagem chegar a zero.

Uso básico

Chame Add antes de iniciar cada goroutine; Done ao final de cada goroutine (usando defer); Wait depois de iniciar todas as 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 deve ocorrer antes do início da goroutine

Chame wg.Add(1) antes de go func(), nunca dentro da goroutine. Caso contrário, Wait poderá retornar antes que a goroutine se registre.

Erro comum: captura da variável do laço

Passe a variável do laço como argumento para a função da goroutine, e não por meio de uma closure, para evitar que todas as goroutines compartilhem a mesma variável.

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

Reutilização de um WaitGroup

Um WaitGroup pode ser reutilizado depois que Wait retornar, mas somente se todas as chamadas anteriores a Done tiverem retornado. Não o reutilize simultaneamente com chamadas a Done ainda pendentes.

WaitGroup com resultados

WaitGroup não coleta resultados — combine-o com um canal ou uma fatia (com mutex) para reunir a saída das 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 com contagem em lote

Você pode passar a contagem total em uma única chamada a Add antes do laço, o que é um pouco mais eficiente do que usar um Add por goroutine.

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

Não copie um WaitGroup

Assim como Mutex, um WaitGroup não deve ser copiado após o primeiro uso. Passe-o por ponteiro ou incorpore-o a uma estrutura passada por ponteiro.

WaitGroup versus errgroup

golang.org/x/sync/errgroup encapsula WaitGroup e adiciona a propagação de erros. Prefira errgroup quando a falha de qualquer goroutine dever interromper as demais.

Combinação com contexto

Use errgroup.WithContext para obter tanto a semântica de WaitGroup quanto um contexto que é cancelado no primeiro erro, interrompendo todas as goroutines de forma limpa.

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

O valor zero pode ser usado

O valor zero de sync.WaitGroup já está pronto para uso — não é necessário um construtor. Basta declará-lo e chamar Add.

Verificação rápida

O que acontece se você chamar wg.Add(1) dentro da goroutine em vez de antes de iniciá-la?

Recapitulação: sync.WaitGroup

Pontos-chave:

Add antes de iniciar a goroutine; Done usando defer dentro da goroutine
Wait bloqueia até a contagem chegar a zero
Nunca copie; nunca chame Add dentro da goroutine
Use errgroup para propagar erros

Perguntas Frequentes

A aula “sync.WaitGroup” é grátis?

Sim — o texto completo de “sync.WaitGroup” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “sync.WaitGroup”?

Aguarde uma coleção de goroutines Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “sync.WaitGroup”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy