Go言語のselect文におけるbreak処理について解説

package main
import "fmt"
func main() {
    // チャネルを作成
    messages := make(chan string)
    // ゴルーチン内でメッセージを送信
    go func() {
        messages <- "こんにちは、Go!"
    }()
    // チャネルからメッセージを受信して表示
    msg := <-messages
    fmt.Println(msg)
}

こんにちは、Go!

package main
import (
    "fmt"
    "time"
)
func main() {
    c1 := make(chan string)
    c2 := make(chan string)
    // ゴルーチンでそれぞれ異なる遅延後にメッセージを送信
    go func() {
        time.Sleep(1 * time.Second)
        c1 <- "c1からのメッセージ"
    }()
    go func() {
        time.Sleep(2 * time.Second)
        c2 <- "c2からのメッセージ"
    }()
    // 最初に受信可能なチャネルのメッセージを表示
    select {
    case msg1 := <-c1:
        fmt.Println(msg1)
    case msg2 := <-c2:
        fmt.Println(msg2)
    }
}

c1からのメッセージ

package main
import "fmt"
func main() {
    // 単純なループ例
    for i := 0; i < 10; i++ {
        if i == 5 {
            // iが5になったらループを抜ける
            break
        }
        fmt.Println("値:", i)
    }
}

値: 0
値: 1
値: 2
値: 3
値: 4

package main
import (
    "fmt"
    "time"
)
func main() {
    message := make(chan string)
    // ゴルーチンでメッセージを送信
    go func() {
        time.Sleep(500 * time.Millisecond)
        message <- "送信完了"
    }()
Loop:
    for {
        select {
        case msg := <-message:
            fmt.Println(msg)
            // ラベル付きbreakでループ全体から抜ける
            break Loop
        default:
            fmt.Println("待機中...")
            time.Sleep(100 * time.Millisecond)
        }
    }
}

待機中...
待機中...
待機中...
送信完了

package main
import (
    "fmt"
    "time"
)
func main() {
    c := make(chan string)
    // ゴルーチンで3秒後にメッセージ送信
    go func() {
        time.Sleep(3 * time.Second)
        c <- "結果が得られました"
    }()
    // 2秒後にタイムアウトする
    timeout := time.After(2 * time.Second)
    select {
    case msg := <-c:
        fmt.Println(msg)
    case <-timeout:
        fmt.Println("タイムアウトしました")
    }
}

タイムアウトしました

package main
import (
    "fmt"
    "time"
)
func main() {
    result := make(chan string)
    errCh := make(chan string)
    // ゴルーチンでエラーを送信
    go func() {
        time.Sleep(500 * time.Millisecond)
        errCh <- "エラーが発生しました"
    }()
    // 無限ループでselectを利用
Loop:
    for {
        select {
        case res := <-result:
            fmt.Println("結果:", res)
        case err := <-errCh:
            fmt.Println("エラー:", err)
            break Loop
        default:
            fmt.Println("待機中...")
            time.Sleep(100 * time.Millisecond)
        }
    }
}

待機中...
待機中...
待機中...
エラー: エラーが発生しました

package main
import (
    "fmt"
    "time"
)
func main() {
    count := 0
Loop:
    for {
        select {
        case <-time.After(200 * time.Millisecond):
            count++
            fmt.Println("カウント:", count)
            if count >= 5 {
                // カウントが5以上でループから抜ける
                break Loop
            }
        }
    }
    fmt.Println("ループ終了")
}

カウント: 1
カウント: 2
カウント: 3
カウント: 4
カウント: 5
ループ終了

package main
import (
    "fmt"
    "time"
)
func main() {
    eventCh := make(chan string)
    // 擬似的なイベントを発生させるゴルーチン
    go func() {
        time.Sleep(500 * time.Millisecond)
        eventCh <- "ユーザー入力イベント"
    }()
    // イベント待ちの無限ループ
Loop:
    for {
        select {
        case event := <-eventCh:
            fmt.Println("イベント検出:", event)
            // イベント処理後にループを終了
            break Loop
        default:
            fmt.Println("イベント待機中...")
            time.Sleep(100 * time.Millisecond)
        }
    }
    fmt.Println("処理終了")
}

イベント待機中...
イベント待機中...
イベント待機中...
イベント検出: ユーザー入力イベント
処理終了

package main
import (
    "fmt"
    "time"
)
func main() {
    message := make(chan string)
    // ゴルーチンでメッセージを送信
    go func() {
        time.Sleep(500 * time.Millisecond)
        message <- "シンプルメッセージ"
    }()
    // 無限ループ内のselect文でメッセージ受信を待つ
Loop:
    for {
        select {
        case msg := <-message:
            fmt.Println(msg)
            // 受信後、ループ全体から抜ける
            break Loop
        default:
            fmt.Println("待機中...")
            time.Sleep(100 * time.Millisecond)
        }
    }
}

待機中...
待機中...
待機中...
シンプルメッセージ

package main
import (
    "fmt"
    "time"
)
func main() {
    resultCh := make(chan string)
    errorCh := make(chan string)
    // 擬似的な結果送信
    go func() {
        time.Sleep(1 * time.Second)
        resultCh <- "データ取得成功"
    }()
    // 擬似的なエラー送信
    go func() {
        time.Sleep(2 * time.Second)
        errorCh <- "エラー発生"
    }()
Loop:
    for {
        select {
        case result := <-resultCh:
            fmt.Println("結果:", result)
            break Loop
        case err := <-errorCh:
            fmt.Println("エラー:", err)
            break Loop
        case <-time.After(3 * time.Second):
            fmt.Println("タイムアウト条件により処理終了")
            break Loop
        default:
            fmt.Println("処理中...")
            time.Sleep(100 * time.Millisecond)
        }
    }
    fmt.Println("プログラム終了")
}

処理中...
処理中...
処理中...
結果: データ取得成功
プログラム終了