Day 012 — sync.WaitGroup

📚 背景知識（読んでから問題へ）

前回学んだselectは「複数のchannelのうち、どれか1つ」を待つための道具でした。しかし実務では「複数のgoroutineを起動し、そのすべてが終わるのを待ってから次に進みたい」という場面が非常に多く発生します。これをchannelだけで書こうとすると、goroutineの数だけ受信を繰り返す必要があり、数が可変だと途端に面倒になります。そこで使うのがsync.WaitGroupです。

📋 コピーvar wg sync.WaitGroup

wg.Add(1)        // 待つべきgoroutineの数をカウンタに加算
go func() {
    defer wg.Done() // 完了したらカウンタを1減らす
    // ...何か処理...
}()

wg.Wait()         // カウンタが0になるまでブロックする

sync.WaitGroupは内部にカウンタを1つ持つだけのシンプルな構造体です。使い方のルールは3つだけです。

• Add(n)でカウンタにnを加算する。goroutineを起動する前に呼ぶのが鉄則（goroutine内で呼ぶと、Wait()が先に実行されてカウンタがまだ0のまま素通りしてしまうrace conditionになりうる）
• Done()でカウンタを1減らす。goroutineの中でdefer wg.Done()と書くのが定石（途中でpanicしても確実にDoneが呼ばれる）
• Wait()はカウンタが0になるまで呼び出し元をブロックする

重要な制約として、sync.WaitGroupはコピーしてはいけません。値渡しするとコピー先とコピー元が別々のカウンタを持つことになり、Wait()が正しく機能しなくなります。そのため関数に渡すときは必ず*sync.WaitGroup（ポインタ）で渡します。この制約はgo vetのcopylocksチェックで静的に検出されます。

もう1つ知っておくべきことは、sync.WaitGroup自体にはタイムアウトの概念がないという点です。「一定時間待ってダメなら諦める」をやりたい場合は、wg.Wait()を別goroutineの中で実行し、その完了をchannelのcloseで外側に通知し、selectでtime.Afterと競わせる、という組み合わせ技が必要になります。前回学んだselectが、ここでまさに活きてきます。

📝 問題

以下の要件を満たす、1つの実行可能なGoプログラムを実装してください。

1. runWorkers(n int, task func(id int) string) []stringを実装してください。n個のgoroutineを起動し、それぞれがtask(id)（idは0からn-1）を実行します。sync.WaitGroupを使ってすべてのgoroutineの完了を待ってから、taskの戻り値をidの順に並べた[]stringを返してください。Addはgoroutine起動前に呼ぶこと、Doneはdeferで呼ぶことを守ってください
2. waitWithTimeout(wg *sync.WaitGroup, timeout time.Duration) boolを実装してください。wg.Wait()がtimeout以内に完了すればtrue、間に合わなければfalseを返してください。sync.WaitGroup自体にはタイムアウト機能がないため、別goroutineでwg.Wait()を実行してその完了をchannelのcloseで通知し、selectとtime.Afterを組み合わせて実装すること
3. mainでは、runWorkersに5個のworkerを異なる待ち時間で走らせ、結果がid順にすべて揃っていることを出力で確認してください
4. mainでは、waitWithTimeoutを2パターン呼び出してください。（a）timeout内にすべてのgoroutineが完了してtrueが返るケース、（b）timeoutより処理が長くかかりfalseが返るケース

go run main.goでそのまま実行できる、完全な1つのプログラムとして提出してください。

🔍 ヒント（段階的開示）

📋 コピーpackage main

import (
	"fmt"
	"sync"
	"time"
)

func runWorkers(n int, task func(id int) string) []string {
	results := make([]string, n)
	var wg sync.WaitGroup

	for id := 0; id < n; id++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			// results[id] = task(id)
		}(id)
	}

	wg.Wait()
	return results
}

func waitWithTimeout(wg *sync.WaitGroup, timeout time.Duration) bool {
	done := make(chan struct{})
	go func() {
		wg.Wait()
		close(done)
	}()

	select {
	case <-done:
		return true
	case <-time.After(timeout):
		return false
	}
}

func main() {
	// ここから、runWorkersとwaitWithTimeoutの動作確認を書いていく
	fmt.Println("skeleton")
}

✅ 模範解答

📋 コピーpackage main

import (
	"fmt"
	"sync"
	"time"
)

// runWorkers は n 個のgoroutineを起動してそれぞれ task(id) を実行し、
// sync.WaitGroup で全ての完了を待ってから、id順に整列した結果を返す。
func runWorkers(n int, task func(id int) string) []string {
	results := make([]string, n)
	var wg sync.WaitGroup

	for id := 0; id < n; id++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			results[id] = task(id)
		}(id)
	}

	wg.Wait()
	return results
}

// waitWithTimeout は wg.Wait() が timeout 以内に完了すれば true、
// 間に合わなければ false を返す。sync.WaitGroup自体にはtimeout機能がないため、
// 別goroutineでWait()し、その完了をchannelのcloseで通知してselectと組み合わせる。
func waitWithTimeout(wg *sync.WaitGroup, timeout time.Duration) bool {
	done := make(chan struct{})
	go func() {
		wg.Wait()
		close(done)
	}()

	select {
	case <-done:
		return true
	case <-time.After(timeout):
		return false
	}
}

func main() {
	fmt.Println("=== runWorkers: 5個のworkerの完了を待って結果を集約 ===")
	results := runWorkers(5, func(id int) string {
		time.Sleep(time.Duration(5-id) * 30 * time.Millisecond)
		return fmt.Sprintf("worker-%d done", id)
	})
	for i, r := range results {
		fmt.Printf("  [%d] %s\n", i, r)
	}

	fmt.Println("\n=== waitWithTimeout: timeout内に完了するケース ===")
	var wgFast sync.WaitGroup
	wgFast.Add(3)
	for i := 0; i < 3; i++ {
		go func(i int) {
			defer wgFast.Done()
			time.Sleep(50 * time.Millisecond)
		}(i)
	}
	ok := waitWithTimeout(&wgFast, 500*time.Millisecond)
	fmt.Println("  完了:", ok)

	fmt.Println("\n=== waitWithTimeout: timeoutより遅いケース ===")
	var wgSlow sync.WaitGroup
	wgSlow.Add(1)
	go func() {
		defer wgSlow.Done()
		time.Sleep(1 * time.Second)
	}()
	ok = waitWithTimeout(&wgSlow, 200*time.Millisecond)
	fmt.Println("  完了:", ok)
}

=== runWorkers: 5個のworkerの完了を待って結果を集約 ===
  [0] worker-0 done
  [1] worker-1 done
  [2] worker-2 done
  [3] worker-3 done
  [4] worker-4 done

=== waitWithTimeout: timeout内に完了するケース ===
  完了: true

=== waitWithTimeout: timeoutより遅いケース ===
  完了: false

※ go run -race main.goでもdata race検出なしを確認済みです。

🪜 Step-by-Step 解説

📋 コピーdone := make(chan struct{})
go func() {
	wg.Wait()
	close(done)
}()

select {
case <-done:
	return true
case <-time.After(timeout):
	return false
}

💡 設計思想・なぜこう書くのか

🌐 他言語との比較

Java のCountDownLatchはカウンタが一度0になったら再利用できず初期値もコンストラクタで固定という点でWaitGroupより制約が強い一方、await(timeout, unit)のようにタイムアウトが最初からAPIに組み込まれています。GoのWaitGroupは逆に「カウンタの増減が自由（Addを後からさらに呼べる）」という柔軟性と引き換えに、タイムアウトは自分でselectと組み合わせて作る、というトレードオフになっています。

🏆 実務での使いどころ

• 並列APIコールの集約: 複数の外部APIやマイクロサービスに並行してリクエストを送り、全レスポンスが揃ってから1つの結果としてまとめて返す（今回のrunWorkersはこの簡易版）
• バッチ処理のfan-out: 大量のレコードをN個のgoroutineで分担処理し、全処理が終わったことを確認してから後続処理（DB書き込みの確定など）に進む
• graceful shutdown時のドレイン待ち: サーバー停止時に「処理中のリクエストが全て完了するまで待つ」ために、リクエストごとにAdd(1)/Done()するWaitGroupをハンドラに仕込む設計
• タイムアウト付き並列処理: waitWithTimeoutのパターンは、「複数の並行処理をなるべく待つが、無限には待てない」という本番運用でよくある要件（例: ヘルスチェック集約、複数キャッシュノードへの書き込み確認）に直接使える

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: runWorkersを改造し、各goroutineが個別のindexではなく共有の合計値（例: 全taskの処理時間の合計）を書き込むように変更してみましょう。その場合、単純なtotal += xではdata raceになることをgo run -raceで確認し、次回学ぶsync.Mutexで保護する必要性を体感してください
• 次回予告: Day 013 — sync.Mutex / RWMutex（実装問題）。複数goroutineが同じ変数を読み書きする場合の排他制御を学びます

🎯 自己評価

自分の回答

気づき・メモ