Day 009 — goroutineの基礎（軽量スレッドとしてのgoroutine）

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

goroutineは、Goのランタイムが管理する軽量な実行単位です。関数呼び出しの前にgoキーワードを付けるだけで、その関数を新しいgoroutineとして非同期に実行できます。

📋 コピーgo doSomething()

これだけでdoSomething()は「呼び出し元とは独立した別の実行の流れ」として動き始めます。OSのスレッドと似た働きをしますが、決定的に違うのはそのコストです。

• OSスレッド: 生成に数MB（デフォルトで1〜8MB程度）の固定スタックを必要とし、生成・切り替え（コンテキストスイッチ）のコストも大きい
• goroutine: 初期スタックはわずか2KB程度で、必要に応じてGoランタイムが自動的に伸縮させる。数千〜数百万個のgoroutineを同時に起動しても現実的なメモリで動く

この軽さを実現しているのが、GoランタイムによるM:Nスケジューリングです。M個のgoroutineをN個のOSスレッドの上で多重化して実行します（NはGOMAXPROCSで制御され、デフォルトはCPUコア数）。つまりgoroutineはOSスレッドに直接対応するのではなく、Goランタイムが独自にスケジューリングする「ユーザー空間の軽量スレッド」です。この仕組みの内部詳細（GMPモデル）はPhase 4で扱いますが、今の段階では「goroutineは安価に大量生成できる」という感覚を持てば十分です。

もう1つ重要なのは、goroutineの実行順序もタイミングも保証されないという点です。

📋 コピーfunc main() {
	go fmt.Println("A")
	go fmt.Println("B")
	fmt.Println("C")
}

このコードは"A" "B" "C"がどんな順序で出力されるか（あるいはA・Bが全く出力されないままmainが終了してしまうか）を一切保証しません。main関数はそれ自体が1つのgoroutine（メインgoroutine）であり、メインgoroutineが終了すると、他のgoroutineが実行途中であってもプログラム全体が終了します。これはGoが並行処理を学ぶ上で最初にぶつかる重要な特性です。

📝 問題

以下のコードは、1〜5の数値を並行に処理するworker関数を5つのgoroutineとして起動しようとしたものです。

📋 コピーpackage main

import "fmt"

func worker(id int) {
	fmt.Printf("worker %d: done\n", id)
}

func main() {
	for i := 1; i <= 5; i++ {
		go worker(i)
	}
}

要件:

1. 概念理解: このコードをgo run main.goで実行すると、何も出力されない・あるいは5行未満しか出力されないことがあります。なぜそうなるのか、メインgoroutineと他のgoroutineの関係を踏まえて説明してください
2. 概念理解: 仮にgo worker(i)の代わりに、無名関数のクロージャでiをキャプチャする以下のような書き方をした場合、

   📋 コピーgo func() {
       fmt.Printf("worker %d: done\n", i)
   }()

   Go 1.22より前のバージョンと、Go 1.22以降のバージョンとで、出力されるidの値の傾向がどう異なる可能性があるか説明してください（forループの変数スコープの仕様変更に関する問題です）
3. 実装: 元のコードを、time.Sleepのような「とりあえず待つ」誤魔化しを使わずに、channelを使って全てのgoroutineの完了を待ち合わせるように修正してください。5つのworkerが確実に全て完了してからmainが終了するようにし、go run main.goで毎回5行すべてが出力されることを確認してください（出力の順序は保証されなくて構いません）

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

🔍 ヒント（段階的開示）

📋 コピーpackage main

import "fmt"

func worker(id int, done chan<- struct{}) {
	fmt.Printf("worker %d: done\n", id)
	done <- struct{}{} // 完了を通知
}

func main() {
	done := make(chan struct{})

	for i := 1; i <= 5; i++ {
		go worker(i, done)
	}

	for i := 0; i < 5; i++ {
		<-done // 1つ完了するたびに受信。5回受信するまでブロックする
	}
}

✅ 模範解答

📋 コピーpackage main

import "fmt"

// worker は id を受け取り、処理完了後に done チャネルへ完了シグナルを送る。
// done は送信専用チャネル型（chan<- struct{}）として宣言し、
// worker がこのチャネルに対して「送信しかしない」という意図を型で明示している。
func worker(id int, done chan<- struct{}) {
	fmt.Printf("worker %d: done\n", id)
	done <- struct{}{}
}

func main() {
	const n = 5
	done := make(chan struct{})

	for i := 1; i <= n; i++ {
		go worker(i, done)
	}

	// n 個の完了シグナルを受信するまで main はここでブロックする。
	// これにより、5つの goroutine が全て完了してから main が終了することが保証される。
	for i := 0; i < n; i++ {
		<-done
	}

	fmt.Println("all workers finished")
}

worker 3: done
worker 1: done
worker 5: done
worker 2: done
worker 4: done
all workers finished

※ 何度実行しても必ず5行のworker N: doneとall workers finishedが出力されますが、worker N: doneの順序は実行のたびに変わり得ます（バグではなく、スケジューリングが非決定的であることの正常な現れです）。

🪜 Step-by-Step 解説

📋 コピーdone := make(chan struct{})

📋 コピーfor i := 1; i <= n; i++ {
	go worker(i, done)
}
for i := 0; i < n; i++ {
	<-done
}

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

🌐 他言語との比較

Java/Pythonのスレッド経験がある人は「スレッド＝コストの高い希少資源」という感覚を持ちがちですが、goroutineは「必要な場所に気軽に使う軽量な道具」という感覚に近いです。一方Node.js経験者は「並行処理といえばシングルスレッド＋非同期I/O」という前提を持ちがちですが、Goのgoroutineは実際に複数のOSスレッド上で真に並列に実行され得る点が異なります（GOMAXPROCSが1より大きい場合）。

🏆 実務での使いどころ

• 並行I/O処理: 複数のAPIへのリクエストや複数ファイルの読み込みを、goroutineで並行に発行してレイテンシを短縮する（例: 5つの外部APIを直列に呼べば合計500msかかるところを、並行に呼べば最も遅い1つの時間で済む）
• バックグラウンドタスク: HTTPリクエストへの応答を返しつつ、ログ送信や集計処理などを別goroutineで裏側に流す
• サーバーのリクエストハンドリング: net/httpのサーバーは、リクエストごとに自動でgoroutineを1つ割り当てて処理する。これによりGoの標準HTTPサーバーは追加の設定なしに高い並行性を持つ
• 完了待ち合わせパターンの基礎: 今回のchannelによる待ち合わせは、次回以降に学ぶsync.WaitGroup（複数goroutineの完了を待つための専用の道具）の理解の土台になる

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: 今回はchan struct{}で「完了した」という事実だけを伝えましたが、workerの処理結果（例えば計算結果のint）をchan intでmain側に送り返し、5つの結果を集計するように改造してみましょう
• 次回予告: Day 010 — channelの基礎（バッファなし/バッファあり）（実装問題）。今回何気なく使ったmake(chan struct{})（バッファなしchannel）の正確な同期の仕組みと、バッファ付きchannelとの違いを深掘りします

🎯 自己評価

自分の回答

気づき・メモ