Day 011 — select文

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

前回、1つのchannelに対して送信・受信を行う基本を学びました。しかし実務では「複数のchannelのうち、どれか1つでも値が来たらそれを処理したい」という場面が頻繁に発生します。それを実現するのがselect文です。

📋 コピーselect {
case v := <-ch1:
    // ch1から受信できた場合
case v := <-ch2:
    // ch2から受信できた場合
default:
    // どのcaseもreadyでない場合（即座に実行される）
}

selectはswitchに似た構文ですが、比較対象は値ではなくchannel操作の実行可否です。挙動のルールは次の通りです。

• 複数のcaseのうち、readyな（送受信可能な）ものがあればそれを実行する
• 複数のcaseが同時にreadyな場合は、擬似ランダムに1つが選ばれる（先頭に書いたcaseが優先されるわけではない）
• どのcaseもreadyでない場合、defaultがあれば即座にdefaultを実行（ブロックしない）。defaultがなければ、いずれかのcaseがreadyになるまでブロックする

selectが真価を発揮するのが、time.Afterと組み合わせたタイムアウト処理です。

📋 コピーselect {
case v := <-ch:
    fmt.Println("受信:", v)
case <-time.After(3 * time.Second):
    fmt.Println("タイムアウト")
}

time.After(d)は、d経過後に現在時刻を1つ送信する<-chan Timeを返す関数です。これをselectのcaseに含めることで、「chから値が来るのを待つが、一定時間待っても来なければ諦める」という処理が、追加のgoroutineやフラグ変数なしにたった数行で書けます。これはGoが「タイムアウト」という頻出パターンを言語プリミティブレベルで自然に表現できる好例です。

もう1つ重要な性質として、selectのcase数はコンパイル時に固定されるという制約があります。動的な数のchannel（例:スライスで渡されたN個のchannel）をselectで同時に監視したい場合は、標準のselect文では書けず、reflect.Selectという別の仕組みが必要になります（これはPhase 3以降で扱う応用テーマです）。今回はcase数が固定の基本形に絞って扱います。

📝 問題

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

1. firstResponse(ch1, ch2, ch3 <-chan string, timeout time.Duration) (string, error) という関数を実装してください。この関数はselect文で3つのchannelを同時に監視し、最初にどれか1つから届いた値をそのまま返してください。どのchannelからも値が来ないままtimeoutが経過した場合は、空文字列とerrors.Newで作成したエラーを返してください（time.Afterを使うこと）
2. mainでは、worker(label string, delay time.Duration) <-chan stringというヘルパー関数（goroutineを起動し、delay後にlabelを送信するchannelを返す）を用意し、遅延の異なる3つのworkerを作ってfirstResponseを呼び出し、最速で応答したworkerのlabelが表示されることを確認してください
3. 3つのworkerすべてがtimeoutより遅く応答するケースも用意し、firstResponseが正しくタイムアウトエラーを返すことを確認してください
4. 同じプログラム内に、selectのdefault節を使ったノンブロッキングなポーリングの例も実装してください（一定回数、短い間隔でchannelを確認し、まだ値がなければ「まだ届いていません」といったログを出し、値が届いたらそこでポーリングをやめる）

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

🔍 ヒント（段階的開示）

📋 コピーpackage main

import (
	"errors"
	"fmt"
	"time"
)

func firstResponse(ch1, ch2, ch3 <-chan string, timeout time.Duration) (string, error) {
	select {
	case v := <-ch1:
		return v, nil
	case v := <-ch2:
		return v, nil
	case v := <-ch3:
		return v, nil
	case <-time.After(timeout):
		return "", errors.New("timeout")
	}
}

func worker(label string, delay time.Duration) <-chan string {
	ch := make(chan string, 1)
	go func() {
		time.Sleep(delay)
		ch <- label
	}()
	return ch
}

func main() {
	ch1 := worker("worker-A", 300*time.Millisecond)
	ch2 := worker("worker-B", 100*time.Millisecond)
	ch3 := worker("worker-C", 500*time.Millisecond)

	result, err := firstResponse(ch1, ch2, ch3, 1*time.Second)
	fmt.Println(result, err)

	// ここから、timeoutケースとdefault節によるポーリングを追加していく
}

✅ 模範解答

📋 コピーpackage main

import (
	"errors"
	"fmt"
	"time"
)

// firstResponse は3つのchannelをselectで同時に監視し、最初に届いた値を返す。
// どのchannelからも値が来ないままtimeoutが経過した場合はエラーを返す。
func firstResponse(ch1, ch2, ch3 <-chan string, timeout time.Duration) (string, error) {
	select {
	case v := <-ch1:
		return v, nil
	case v := <-ch2:
		return v, nil
	case v := <-ch3:
		return v, nil
	case <-time.After(timeout):
		return "", errors.New("timeout: どのworkerからも応答がありませんでした")
	}
}

// worker は指定した遅延の後、labelをchannelへ送信するgoroutineを起動し、
// 受信専用channelを返す。
func worker(label string, delay time.Duration) <-chan string {
	ch := make(chan string, 1)
	go func() {
		time.Sleep(delay)
		ch <- label
	}()
	return ch
}

func main() {
	fmt.Println("=== 複数workerのうち最速の応答を待つ ===")
	ch1 := worker("worker-A", 300*time.Millisecond)
	ch2 := worker("worker-B", 100*time.Millisecond)
	ch3 := worker("worker-C", 500*time.Millisecond)

	result, err := firstResponse(ch1, ch2, ch3, 1*time.Second)
	if err != nil {
		fmt.Println("エラー:", err)
	} else {
		fmt.Println("最速で応答したのは:", result)
	}

	fmt.Println("\n=== timeoutケース（全workerがtimeoutより遅い） ===")
	slowCh1 := worker("slow-A", 2*time.Second)
	slowCh2 := worker("slow-B", 2*time.Second)
	slowCh3 := worker("slow-C", 2*time.Second)
	_, err = firstResponse(slowCh1, slowCh2, slowCh3, 300*time.Millisecond)
	if err != nil {
		fmt.Println("エラー:", err)
	}

	fmt.Println("\n=== default節によるノンブロッキング・ポーリング ===")
	pollCh := worker("poll-result", 250*time.Millisecond)
	received := false
	for i := 0; i < 5 && !received; i++ {
		select {
		case v := <-pollCh:
			fmt.Println("ポーリング中に受信:", v)
			received = true
		default:
			fmt.Printf("  まだ届いていません、ポーリング%d回目\n", i+1)
			time.Sleep(100 * time.Millisecond)
		}
	}
	if !received {
		fmt.Println("  ポーリング終了までに受信できませんでした")
	}
}

=== 複数workerのうち最速の応答を待つ ===
最速で応答したのは: worker-B

=== timeoutケース（全workerがtimeoutより遅い） ===
エラー: timeout: どのworkerからも応答がありませんでした

=== default節によるノンブロッキング・ポーリング ===
  まだ届いていません、ポーリング1回目
  まだ届いていません、ポーリング2回目
  まだ届いていません、ポーリング3回目
ポーリング中に受信: poll-result

※ goroutineのスケジューリングにより細かいタイミングは実行のたびに変わりますが、傾向は毎回同じです。

🪜 Step-by-Step 解説

📋 コピーselect {
case v := <-pollCh:
	received = true
default:
	time.Sleep(100 * time.Millisecond)
}

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

🌐 他言語との比較

Promise.raceやCompletableFuture.anyOfを使ったことがある人にとっては、「複数の非同期処理のうち最速のものを待つ」という発想自体は馴染みやすいはずです。違いは、Goではtime.Afterによるタイムアウトも同じselect構文の中に対等なcaseとして書ける点で、他言語のように「本体の処理」と「タイムアウト用の特別なAPI」を別々に組み合わせる必要がありません。

🏆 実務での使いどころ

• 外部APIへのタイムアウト付きリクエスト: 複数のレプリカ/フォールバック先に同時にリクエストを送り、最初に返ってきた応答を採用しつつ、一定時間で諦めるパターン（今回のfirstResponseはこの簡易版）
• graceful shutdown: メインの処理channelと、OSシグナルを受け取るchannel（os.Signal）をselectで同時に監視し、シグナルを受けたら安全に終了処理へ移る実装は本番サービスの定番パターン
• サーキットブレーカーやリトライ機構: context.Done()（内部的にはchannel）と処理完了channelをselectで監視し、キャンセルと正常完了のどちらが先に起きたかで分岐する
• イベントループ的な多重化: 複数のイベントソース（タイマー、外部からの通知、内部キュー）を1つのselectループで捌く、単純だが堅牢なディスパッチャの実装

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: firstResponseのtimeoutをtime.Afterではなくcontext.WithTimeoutで実装し直してみましょう。ctx.Done()をselectのcaseに使う書き方は、Phase 2の次のテーマ「context パッケージ」への橋渡しになります
• 次回予告: Day 012 — sync.WaitGroup（実装問題）。複数のgoroutineの完了を、channelを使わずに待ち合わせる標準的な方法を学びます

🎯 自己評価

自分の回答

気づき・メモ