Goのselect構文について解説

package main
import (
	"fmt"
	"time"
)
func main() {
	// チャネルの宣言
	messageChan := make(chan string)
	timeoutChan := time.After(2 * time.Second)
	// ゴルーチンからメッセージ送信
	go func() {
		// 模擬的な作業時間を経たメッセージ送信
		time.Sleep(1 * time.Second)
		messageChan <- "メッセージ受信"
	}()
	// select構文でチャネルの動作を監視
	select {
	case msg := <-messageChan:
		// 受信チャネルが準備できた場合の処理
		fmt.Println("受信:", msg)
	case <-timeoutChan:
		// タイムアウトチャネルが先に準備できた場合の処理
		fmt.Println("タイムアウト発生")
	}
}

受信: メッセージ受信

select {
case <チャネル操作1>:
	// 操作1が実行可能な場合の処理
case <チャネル操作2>:
	// 操作2が実行可能な場合の処理
default:
	// どのチャネルも準備できていない場合の処理
}

case value := <-channel:
    // channelから値を受信した場合の処理

case channel <- value:
    // channelへ値を送信できた場合の処理

package main
import (
	"fmt"
	"time"
)
func main() {
	receiveChan := make(chan string)
	sendChan := make(chan string)
	// ゴルーチンでチャネルに値を送信
	go func() {
		time.Sleep(500 * time.Millisecond)
		receiveChan <- "受信データ"
	}()
	go func() {
		time.Sleep(300 * time.Millisecond)
		sendChan <- "送信データ"
	}()
	select {
	case msg := <-receiveChan:
		// 受信の場合の処理
		fmt.Println("受信:", msg)
	case sendChan <- "新たなデータ":
		// 送信が完了した場合の処理
		fmt.Println("送信完了")
	}
}

送信完了

package main
import (
	"fmt"
)
func main() {
	channelA := make(chan int)
	channelB := make(chan int)
	select {
	case <-channelA:
		fmt.Println("channelAから受信")
	case channelB <- 10:
		fmt.Println("channelBに送信")
	default:
		// どのチャネルも準備できなければここが実行される
		fmt.Println("どの操作も準備不可")
	}
}

どの操作も準備不可

package main
import (
	"fmt"
	"time"
)
func main() {
	// チャネルの宣言
	dataChan := make(chan string)
	doneChan := make(chan struct{})
	// ゴルーチンでデータ送信
	go func() {
		time.Sleep(700 * time.Millisecond)
		dataChan <- "データ到着"
	}()
	// ゴルーチンで終了シグナル送信
	go func() {
		time.Sleep(1 * time.Second)
		doneChan <- struct{}{}
	}()
	// select構文で複数のチャネルを監視
	for i := 0; i < 2; i++ {
		select {
		case data := <-dataChan:
			fmt.Println("受信:", data)
		case <-doneChan:
			fmt.Println("処理終了シグナル受信")
		}
	}
}

受信: データ到着
処理終了シグナル受信

package main
import (
	"fmt"
	"time"
)
func main() {
	// メッセージ送信用チャネルとタイムアウト用チャネルの作成
	messageChan := make(chan string)
	timeoutChan := time.After(2 * time.Second)
	// ゴルーチンで遅延後にメッセージ送信
	go func() {
		time.Sleep(1 * time.Second)
		messageChan <- "処理完了"
	}()
	// select構文でタイムアウトとメッセージ受信を監視
	select {
	case msg := <-messageChan:
		fmt.Println("メッセージ:", msg)
	case <-timeoutChan:
		fmt.Println("タイムアウト発生")
	}
}

メッセージ: 処理完了

package main
import (
	"fmt"
	"time"
)
func main() {
	chanA := make(chan string)
	chanB := make(chan string)
	// ゴルーチンでchanAにメッセージ送信
	go func() {
		time.Sleep(500 * time.Millisecond)
		chanA <- "チャネルAからのメッセージ"
	}()
	// ゴルーチンでchanBにメッセージ送信
	go func() {
		time.Sleep(700 * time.Millisecond)
		chanB <- "チャネルBからのメッセージ"
	}()
	// 複数チャネルを監視する
	for i := 0; i < 2; i++ {
		select {
		case msgA := <-chanA:
			fmt.Println("受信:", msgA)
		case msgB := <-chanB:
			fmt.Println("受信:", msgB)
		}
	}
}

受信: チャネルAからのメッセージ
受信: チャネルBからのメッセージ