Go语言中动态选择通道：使用reflect.Select实现灵活的并发通信

select {
case <-c1:
    // 从c1接收数据
case data := <-c2:
    // 从c2接收数据
case c3 <- value:
    // 向c3发送数据
default:
    // 所有通道都未准备好时执行
}

package main

import (
    "log"
    "reflect"
    "time"
)

// sendToAny 尝试将数据发送到给定通道切片中的任意一个通道
// 返回成功发送数据的通道在切片中的索引
func sendToAny(ob int, chs []chan int) int {
    set := []reflect.SelectCase{}
    for _, ch := range chs {
        set = append(set, reflect.SelectCase{
            Dir:  reflect.SelectSend,       // 操作方向：发送
            Chan: reflect.ValueOf(ch),      // 通道本身
            Send: reflect.ValueOf(ob),      // 要发送的值
        })
    }
    // 执行动态选择操作，阻塞直到某个发送操作完成
    to, _, _ := reflect.Select(set)
    return to
}

// recvFromAny 尝试从给定通道切片中的任意一个通道接收数据
// 返回接收到的值和接收数据的通道在切片中的索引
func recvFromAny(chs []chan int) (val int, from int) {
    set := []reflect.SelectCase{}
    for _, ch := range chs {
        set = append(set, reflect.SelectCase{
            Dir:  reflect.SelectRecv,       // 操作方向：接收
            Chan: reflect.ValueOf(ch),      // 通道本身
        })
    }
    // 执行动态选择操作，阻塞直到某个接收操作完成
    from, valValue, _ := reflect.Select(set)
    // 将反射值转换为实际类型
    val = valValue.Interface().(int)
    return
}

package main

import (
    "log"
    "reflect"
    "time"
)

// sendToAny 尝试将数据发送到给定通道切片中的任意一个通道
// 返回成功发送数据的通道在切片中的索引
func sendToAny(ob int, chs []chan int) int {
    set := []reflect.SelectCase{}
    for _, ch := range chs {
        set = append(set, reflect.SelectCase{
            Dir:  reflect.SelectSend,
            Chan: reflect.ValueOf(ch),
            Send: reflect.ValueOf(ob),
        })
    }
    to, _, _ := reflect.Select(set)
    return to
}

// recvFromAny 尝试从给定通道切片中的任意一个通道接收数据
// 返回接收到的值和接收数据的通道在切片中的索引
func recvFromAny(chs []chan int) (val int, from int) {
    set := []reflect.SelectCase{}
    for _, ch := range chs {
        set = append(set, reflect.SelectCase{
            Dir:  reflect.SelectRecv,
            Chan: reflect.ValueOf(ch),
        })
    }
    from, valValue, _ := reflect.Select(set)
    val = valValue.Interface().(int) // 类型断言
    return
}

func main() {
    // 创建一个包含5个通道的切片
    channels := []chan int{}
    for i := 0; i < 5; i++ {
        channels = append(channels, make(chan int, 1)) // 使用带缓冲的通道，避免死锁
    }

    // 启动一个协程，持续向任意通道发送数据
    go func() {
        for i := 0; i < 10; i++ {
            // 模拟发送前的处理时间
            time.Sleep(time.Millisecond * 50)
            x := sendToAny(i, channels)
            log.Printf("Sent %v to ch%v", i, x)
        }
    }()

    // 主协程持续从任意通道接收数据
    for i := 0; i < 10; i++ {
        // 模拟接收前的处理时间
        time.Sleep(time.Millisecond * 100)
        v, x := recvFromAny(channels)
        log.Printf("Received %v from ch%v", v, x)
    }

    // 确保所有协程完成，实际应用中可能需要更复杂的同步机制
    time.Sleep(time.Second)
}