Go の並行処理で使う WaitGroup と errgroup の違いを解説。基本の使い方、エラー処理、WithContext による途中キャンセルまで整理します。

WaitGroup と errgroup の違いを理解する

Go で並行処理を行う場合によく登場するのが <code>sync.WaitGroup</code> と <code>errgroup</code> です。
名前は似ていますが、役割や使いどころには大きな違いがあります。
この記事では、WaitGroup, errgroup はそれぞれ何ができてどういった違いがあるのかを整理します。
<h2 id="contents">contents</h2>
<ol>
<li><a href="#waitgroup%E5%AE%8C%E4%BA%86%E3%82%92%E5%BE%85%E3%81%A4%E3%81%9F%E3%82%81%E3%81%AE%E5%9F%BA%E6%9C%AC%E3%83%84%E3%83%BC%E3%83%AB">WaitGroup：完了を待つための基本ツール</a>
<ol>
<li><a href="#%E3%82%A8%E3%83%A9%E3%83%BC%E3%81%8C%E5%87%BA%E3%81%A6%E3%82%82%E6%9C%80%E5%BE%8C%E3%81%BE%E3%81%A7%E5%AE%9F%E8%A1%8C%E3%81%95%E3%82%8C%E3%82%8B">エラーが出ても最後まで実行される</a></li>
<li><a href="#%E3%82%A8%E3%83%A9%E3%83%BC%E3%82%92%E5%8F%8E%E9%9B%86%E3%81%99%E3%82%8B%E5%A0%B4%E5%90%88">エラーを収集する場合</a></li>
</ol>
</li>
<li><a href="#errgroup%E3%82%A8%E3%83%A9%E3%83%BC%E3%82%92%E6%89%B1%E3%81%88%E3%82%8B%E6%8B%A1%E5%BC%B5%E7%89%88">errgroup：エラーを扱える拡張版</a>
<ol>
<li><a href="#withcontext-%E3%81%AB%E3%82%88%E3%82%8B%E9%80%94%E4%B8%AD%E3%82%AD%E3%83%A3%E3%83%B3%E3%82%BB%E3%83%AB">WithContext による途中キャンセル</a></li>
</ol>
</li>
<li><a href="#waitgroup%E3%81%A8errgroup-%E9%81%95%E3%81%84%E3%81%AE%E6%95%B4%E7%90%86">WaitGroupとerrgroup 違いの整理</a></li>
</ol>
<h2 id="waitgroup完了を待つための基本ツール">WaitGroup：完了を待つための基本ツール</h2>
<a href="https://pkg.go.dev/sync#WaitGroup" rel="noopener noreferrer" target="_blank">sync.WaitGroup</a> は標準ライブラリが提供するもっとも基本的な同期機構です。複数の goroutine
を並行実行し、それらがすべて終わるまで待機することができます。
<pre><code class="hljs language-go">package main

import (
 "fmt"
 "sync"
)

func main() {
 var wg sync.WaitGroup

 for i := 1; i &#x3C;= 3; i++ {
 i := i
 wg.Go(func() {
 fmt.Println("task", i, "done")
 })
 }

 wg.Wait()
 fmt.Println("all tasks finished")
}

</code></pre>
上記のコードでは 3 つのタスクを並行実行し、すべての終了を待っています。
実行結果は次のようになります（実行順は毎回変わります）。
<pre><code class="hljs language-console">task 1 done
task 3 done
task 2 done
all tasks finished
</code></pre>
このように WaitGroup は「終了を待つ」だけで、エラー処理などは持っていません。
<h3 id="エラーが出ても最後まで実行される">エラーが出ても最後まで実行される</h3>
次に、WaitGroup で「タスクがエラーを返した場合」を見てみます。
<pre><code class="hljs language-go">package main

import (
 "fmt"
 "sync"
)

func doWork(id int) error {
 if id == 2 {
 return fmt.Errorf("task %d failed", id)
 }
 fmt.Println("task", id, "done")
 return nil
}

func main() {
 var wg sync.WaitGroup

 for i := 1; i &#x3C;= 3; i++ {
 i := i
 wg.Go(func() {
 if err := doWork(i); err != nil {
 // 途中キャンセルはできないのでログに出すだけ
 fmt.Println("error:", err)
 }
 })
 }

 wg.Wait()
 fmt.Println("all tasks finished")
}
</code></pre>
実行結果：
<pre><code class="hljs language-console">task 1 done
error: task 2 failed
task 3 done
all tasks finished
</code></pre>
WaitGroup には「エラーを契機に途中で止める機能」がありません。エラーは拾ってログに出すことはできますが、全体の処理は最後まで実行されます。
つまり「全タスクをやり切る」用途に向いているのが WaitGroup です。
<h3 id="エラーを収集する場合">エラーを収集する場合</h3>
WaitGroup はエラー処理をサポートしていませんが、エラーチャネルを自前で用意することで「どのタスクで失敗したか」を収集することができます。
<pre><code class="hljs language-go">package main

import (
 "fmt"
 "sync"
)

func doWork(id int) error {
 if id == 2 {
 return fmt.Errorf("task %d failed", id)
 }
 fmt.Println("task", id, "done")
 return nil
}

func main() {
 var wg sync.WaitGroup
 errs := make(chan error, 3)

 for i := 1; i &#x3C;= 3; i++ {
 i := i
 wg.Go(func() {
 if err := doWork(i); err != nil {
 errs &#x3C;- err
 }
 })
 }

 wg.Wait()
 close(errs)

 for err := range errs {
 fmt.Println("error:", err)
 }
}

</code></pre>
実行結果：
<pre><code class="hljs language-console">task 1 done
task 3 done
error: task 2 failed
</code></pre>
このように WaitGroup だけではエラーを返せないため、必要であれば自前で集約処理を書く必要があります。
ただしこの方法では「全部のエラーを集められる」一方で、「途中キャンセル」はできません。
<h2 id="errgroupエラーを扱える拡張版">errgroup：エラーを扱える拡張版</h2>
一方で <a href="https://pkg.go.dev/golang.org/x/sync/errgroup" rel="noopener noreferrer" target="_blank">errgroup</a> は、WaitGroup に「エラー処理機能」を追加した外部パッケージ（<code>golang.org/x/sync/errgroup</code>）です。
基本の使い方は WaitGroup とよく似ていますが、<code>Go</code> に渡す関数が <code>error</code> を返せる点が異なります。
そして、<code>Wait()</code> で最初に発生したエラーを返してくれます。
<pre><code class="hljs language-go">package main

import (
 "fmt"

 "golang.org/x/sync/errgroup"
)

func doWork(id int) error {
 if id == 2 {
 return fmt.Errorf("task %d failed", id)
 }
 fmt.Println("task", id, "done")
 return nil
}

func main() {
 var g errgroup.Group

 for i := 1; i &#x3C;= 3; i++ {
 i := i
 g.Go(func() error {
 return doWork(i)
 })
 }

 if err := g.Wait(); err != nil {
 fmt.Println("[errgroup] error:", err)
 }
}

</code></pre>
実行結果：
<pre><code class="hljs language-console">task 1 done
task 3 done
[errgroup] error: task 2 failed
</code></pre>
このように、WaitGroup と異なり 最初のエラーを呼び出し元に返すことができます。
ただし 複数のエラーが同時に起きても、返ってくるのは最初の 1 件だけ である点には注意が必要です。
<h3 id="withcontext-による途中キャンセル">WithContext による途中キャンセル</h3>
さらに <code>errgroup.WithContext</code> を使うと、「1つのタスクが失敗したら他の処理をキャンセルする」ことができます。
内部的には <code>context.Context</code> を利用しており、goroutine 側が <code>ctx.Done()</code> をチェックすることで早期終了が可能です。
<pre><code class="hljs language-go">package main

import (
 "context"
 "errors"
 "fmt"
 "time"

 "golang.org/x/sync/errgroup"
)

func doWork(ctx context.Context, id int) error {
 // 処理前にキャンセル済みなら即終了
 select {
 case &#x3C;-ctx.Done():
 fmt.Println("task", id, "canceled (pre)")
 return ctx.Err()
 default:
 }

 // 疑似的な処理
 time.Sleep(time.Duration(id) * 100 * time.Millisecond)

 // 処理途中のキャンセルも確認
 select {
 case &#x3C;-ctx.Done():
 fmt.Println("task", id, "canceled (mid)")
 return ctx.Err()
 default:
 }

 // 業務エラーの例
 if id == 2 {
 return fmt.Errorf("task %d failed", id)
 }

 fmt.Println("task", id, "done")
 return nil
}

func main() {
 fmt.Println("[RUN] errgroup.WithContext (distinguish cancel vs failure)")

 g, ctx := errgroup.WithContext(context.Background())

 for i := 1; i &#x3C;= 5; i++ {
 i := i
 g.Go(func() error {
 return doWork(ctx, i)
 })
 }

 if err := g.Wait(); err != nil {
 switch {
 case errors.Is(err, context.Canceled):
 fmt.Println("[errgroup] canceled:", err) // 他タスク由来のキャンセル
 case errors.Is(err, context.DeadlineExceeded):
 fmt.Println("[errgroup] deadline exceeded:", err) // タイムアウト
 default:
 fmt.Println("[errgroup] failure:", err) // 業務エラー（例: task 2 failed）
 }
 } else {
 fmt.Println("[errgroup] all tasks finished")
 }
}
</code></pre>
実行結果：
<pre><code class="hljs language-console">[RUN] errgroup.WithContext (distinguish cancel vs failure)
task 1 done
[errgroup] failure: task 2 failed
task 3 canceled (mid)
task 4 canceled (mid)
task 5 canceled (mid)
</code></pre>
ここでは <code>task 2</code> が失敗した時点で <code>ctx</code> がキャンセルされ、残りのタスクは中断されます。
このように errgroup は「途中キャンセル」をサポートできる点が WaitGroup との大きな違いです。
<h2 id="waitgroupとerrgroup-違いの整理">WaitGroupとerrgroup 違いの整理</h2>
ここまでの違いを表にまとめると以下の通りです。



































<table><thead><tr><th></th><th>WaitGroup (sync)</th><th>errgroup (x/sync)</th></tr></thead><tbody><tr><td>提供元</td><td>標準ライブラリ <code>sync</code></td><td>外部パッケージ <code>golang.org/x/sync/errgroup</code></td></tr><tr><td>目的</td><td>複数処理の完了を待つだけ</td><td>複数処理の完了待ち + エラー処理</td></tr><tr><td>エラー処理</td><td>自前でログや集約が必要</td><td>最初のエラーだけ <code>Wait()</code> が返す</td></tr><tr><td>複数エラー</td><td>自前で集約すれば可能</td><td>不可（1つだけ）</td></tr><tr><td>途中キャンセル</td><td>できない</td><td>WithContext で可能（要 ctx チェック）</td></tr></tbody></table>
<h2 id="まとめ">まとめ</h2>
<ul>
<li>WaitGroup は「複数の処理が全部終わるまで待つ」ことに特化しており、エラーは自前で処理する必要がある。</li>
<li>errgroup は「最初のエラーを返す」ことができ、<code>WithContext</code> を使えば「失敗したら全体をキャンセル」する仕組みも実現できる。</li>
<li>ただし errgroup が返すのは最初の 1 件のエラーだけ。複数エラーをすべて収集したい場合は WaitGroup + エラーチャネルなど自前の仕組みが必要になる。</li>
</ul>
用途によって使い分けると便利。
<ul>
<li>全部やり切る処理 → WaitGroup</li>
<li>失敗したら途中で止めたい処理 → errgroup</li>
</ul>

























<table><thead><tr><th>シナリオ</th><th>適したツール</th></tr></thead><tbody><tr><td>全タスク完了を待ちたい</td><td>WaitGroup</td></tr><tr><td>全エラーを集めたい</td><td>WaitGroup + エラーチャネル</td></tr><tr><td>1つでも失敗したら即エラーにしたい</td><td>errgroup</td></tr><tr><td>失敗時に残り処理を止めたい</td><td>errgroup.WithContext</td></tr></tbody></table>

Author