1. Home
  2. Golang
  3. GuideToBecomingGoDeveloper
  4. GoingDeeper
  5. Select 構文 - Golang learning step 2-7

Select 構文 - Golang learning step 2-7

  • 公開日
  • カテゴリ：GoingDeeper
  • タグ：Golang,roadmap.sh,学習メモ
Select 構文 - Golang learning step 2-7

roadmap.sh > Go > Going Deeper > Select の学習を進めていきます。

※ 学習メモとしての記録ですが、後にこのセクションを学ぶ道しるべとなるよう、ですます調で記載しています。

contents

  1. 開発環境
  2. 参考 URL
  3. Select 構文
  4. 基本的な構文
  5. select の動作のポイント
    1. 1. 複数チャネルの監視
    2. 2. 非ブロッキング操作の実現
    3. 3. タイムアウトの設定
  6. 具体的な使用例
    1. 1. 複数チャネルの監視
    2. 2. タイムアウト付きのチャネル待機
    3. 3. for-select パターン
  7. Select の利用場面
  8. Select の重要なポイント

開発環境

  • チップ: Apple M2 Pro
  • OS: macOS Sonoma
  • go version: go1.23.2 darwin/arm64

参考 URL

Select 構文

Select 構文は、Go において複数のチャネルを監視し、利用可能なチャネルの通信を待機するための構文です。特に複数のゴルーチンからのメッセージを効率よく処理する場合に役立ちます。Select 構文の特徴は、複数のチャネル操作を一度に待つことができ、いずれかの操作が可能になった際にその操作を実行する点です。

Select 構文は、その中のいずれかのケースが実行可能になるまでブロックされ、実行可能になったケースを実行します。複数のケースが実行可能な場合は、その中からランダムに 1 つが選択されます。Select 構文は switch 文に似ていますが、Select 構文の場合、case 文はチャネルに対する送信または受信といった通信操作を指します。

基本的な構文

select {
case msg1 := <-ch1:
  // チャネル ch1 からのメッセージを受信
case ch2 <- msg2:
  // チャネル ch2 にメッセージを送信
default:
  // どのチャネルも準備できていない場合の処理
}

select の動作のポイント

1. 複数チャネルの監視

複数の case が用意されている場合、Go ランタイムは準備ができたチャネルをランダムに選んで処理を実行します。

select {
case msg1 := <-ch1:
  fmt.Println("ch1から受信:", msg1)
case msg2 := <-ch2:
  fmt.Println("ch2から受信:", msg2)
}

2. 非ブロッキング操作の実現

default 文がある場合、すべてのチャネルが未準備でもブロックされず、default 文が即座に実行されます。

select {
case msg := <-ch:
  fmt.Println("受信:", msg)
default:
  fmt.Println("メッセージなし")
}

3. タイムアウトの設定

time.After を使ってタイムアウトを設定することで、一定時間が経過した場合の処理も可能です。

select {
case result := <-ch:
  fmt.Println("結果:", result)
case <-time.After(1 * time.Second):
  fmt.Println("タイムアウト")
}

具体的な使用例

1. 複数チャネルの監視

以下は、2 つのゴルーチンからデータを受け取る例です。

package main

import (
  "fmt"
  "time"
)

func main() {
  ch1 := make(chan string)
  ch2 := make(chan string)

  // 送信側ゴルーチン1
  go func() {
    time.Sleep(2 * time.Second)
    ch1 <- "メッセージ1"
  }()

  // 送信側ゴルーチン2
  go func() {
    time.Sleep(1 * time.Second)
    ch2 <- "メッセージ2"
  }()

  // 複数のチャネルを監視
  for i := 0; i < 2; i++ {
    select {
    case msg1 := <-ch1:
      fmt.Println("ch1から受信:", msg1)
    case msg2 := <-ch2:
      fmt.Println("ch2から受信:", msg2)
    }
  }
}
// 出力:
// ch2から受信: メッセージ2
// ch1から受信: メッセージ1

2. タイムアウト付きのチャネル待機

package main

import (
  "fmt"
  "time"
)

func main() {
  ch := make(chan string)

  go func() {
    time.Sleep(5 * time.Second)
    ch <- "Hello!"
  }()

  select {
  case msg := <-ch:
    fmt.Println("Received:", msg)
  case <-time.After(3 * time.Second):
    fmt.Println("Timeout!")
  }
}
// 出力: Timeout!

このコードでは、3 秒間だけ ch からのメッセージを待ちますが、メッセージが 5 秒後に来るため、タイムアウトが発生して 'Timeout!' が表示されます。

3. for-select パターン

for-select パターンは、Go での並行処理において非常に一般的なパターンです。このパターンを使用することで、プログラムが終了するまで継続的にチャネルを監視し、適切なタイミングでプログラムを終了させることができます。

package main

import (
    "fmt"
    "time"
)

func worker(done chan bool, dataCh chan int) {
    for {
        select {
        case <-done:
            fmt.Println("ワーカーを終了します")
            return
        case data := <-dataCh:
            // データを処理
            fmt.Printf("受信したデータ: %d\n", data)
            time.Sleep(1 * time.Second) // 処理時間をシミュレート
        }
    }
}

func main() {
    done := make(chan bool)
    dataCh := make(chan int)

    // ワーカーの起動
    go worker(done, dataCh)

    // データを送信
    for i := 1; i <= 3; i++ {
        dataCh <- i
    }

    // 終了シグナルを送信
    done <- true
    fmt.Println("メインプログラムを終了します")
}
// 出力:
// 受信したデータ: 1
// 受信したデータ: 2
// 受信したデータ: 3
// ワーカーを終了します
// メインプログラムを終了します

このパターンの主な特徴と利点

  1. 継続的な処理
    • for ループ内で select を使用することで、チャネルを継続的に監視できます。
    • 複数のイベントに対して常時待機状態を維持できます。
  2. グレースフルシャットダウン
    • done チャネルを使用することで、ゴルーチンを適切なタイミングで終了できます。
    • リソースのクリーンアップや保留中の処理の完了を制御できます。
  3. 柔軟な拡張性
    • 新しいチャネルやケースを簡単に追加できます。
    • タイムアウトや他のシグナルとの組み合わせも容易です。

以下は、データ処理にタイムアウトを追加した例です。

func workerWithTimeout(done chan bool, dataCh chan int) {
    for {
        select {
        case <-done:
            fmt.Println("ワーカーを終了します")
            return
        case data := <-dataCh:
            // データ処理のタイムアウト制御
            select {
            case <-time.After(2 * time.Second):
                fmt.Printf("データ %d の処理がタイムアウトしました\n", data)
            default:
                fmt.Printf("受信したデータ: %d\n", data)
                time.Sleep(1 * time.Second) // 処理時間をシミュレート
            }
        }
    }
}

for-select パターンは、特にバックグラウンドジョブ、データストリームの処理、長時間実行されるサービスなど、多くのユースケースで活用されています。このパターンを理解し適切に使用することで、より堅牢な並行処理を実装できます。

Select の利用場面

  1. 複数のゴルーチンからのメッセージの受信
    • Select 構文を使うことで、複数のゴルーチンが生成するメッセージを効率的に処理できる。
  2. タイムアウトやキャンセル処理
    • チャネルがブロックされるリスクを軽減し、スムーズにプログラムが進行するように制御できる。

Select の重要なポイント

  1. ランダム性
    • 複数のcaseが同時に準備できた場合、ランダムに1つが選択されます。これは公平性を確保するためです。
  2. デッドロック検出
    • すべての case がブロックされ、default ケースもない場合、select 文は永遠に待機し続けるため、プログラム全体が停止するデッドロックが発生する可能性があります。
  3. default の使用
    • default ケースを設定することで、非ブロッキング操作を実現できます。
  4. チャネルのクローズ検出
    • チャネルがクローズされたことを2番目の戻り値（ok）で検知できます。これによりチャネルの状態を適切に管理できます。
select {
case msg, ok := <-ch:
  if !ok {
    fmt.Println("チャネルがクローズされました")
    return
  }
  fmt.Println("受信:", msg)
}

まとめ

  • Select 構文による複数チャネルの効率的な監視・制御
  • ゴルーチン間の通信制御における基本的な構文パターン
  • 複数のチャネル処理におけるランダム性による公平性の確保
  • default句による非ブロッキング操作の実現
  • time.After を用いたタイムアウト制御の実装
  • for-select パターンによる継続的な処理とグレースフルシャットダウンの実現
  • チャネルのクローズ状態の適切な検知と管理
  • デッドロック回避のための適切な設計の重要性

[Prev] Step 2-6: バッファ（Buffer）

Author

rito

  • Backend Engineer
  • Tokyo, Japan
  • PHP 5 技術者認定上級試験　認定者
  • 統計検定 3 級