Go语言：使用reflect实现动态select操作

select {
    case <- c1:
        // 从c1接收到数据
    case val := <- c2:
        // 从c2接收到数据
    case c3 <- data:
        // 向c3发送数据
    default:
        // 非阻塞操作，如果没有通道准备好，则立即执行
}

type SelectCase struct {
    Dir  SelectDir     // 操作方向：发送、接收或默认
    Chan reflect.Value // 通道本身的reflect.Value表示
    Send reflect.Value // 如果是发送操作，表示要发送的值
}

func Select(cases []SelectCase) (chosen int, recv reflect.Value, recvOK bool)

package main

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

// sendToAny 尝试向chs切片中的任意一个通道发送ob
// 返回成功发送到的通道在切片中的索引
func sendToAny(ob int, chs []chan int) int {
    set := []reflect.SelectCase{}
    for _, ch := range chs {
        // 构建SelectCase，方向为发送，通道为当前ch，发送值为ob
        set = append(set, reflect.SelectCase{
            Dir:  reflect.SelectSend,
            Chan: reflect.ValueOf(ch),
            Send: reflect.ValueOf(ob),
        })
    }
    // 执行动态select操作
    // chosen: 成功发送的通道索引
    // _: recvValue，对于发送操作无意义
    // _: recvOK，对于发送操作通常为true
    chosen, _, _ := reflect.Select(set)
    return chosen
}

// recvFromAny 尝试从chs切片中的任意一个通道接收数据
// 返回接收到的值和数据来源通道在切片中的索引
func recvFromAny(chs []chan int) (val int, from int) {
    set := []reflect.SelectCase{}
    for _, ch := range chs {
        // 构建SelectCase，方向为接收，通道为当前ch
        set = append(set, reflect.SelectCase{
            Dir:  reflect.SelectRecv,
            Chan: reflect.ValueOf(ch),
        })
    }
    // 执行动态select操作
    // from: 成功接收的通道索引
    // valValue: 接收到的值的reflect.Value表示
    // _: recvOK，表示是否成功接收或通道是否关闭
    from, valValue, _ := reflect.Select(set)
    // 将reflect.Value转换回原始类型（int）
    val = valValue.Interface().(int)
    return
}

func main() {
    // 创建一个包含5个int类型通道的切片
    channels := []chan int{}
    for i := 0; i < 5; i++ {
        channels = append(channels, make(chan int))
    }

    // 启动一个goroutine，持续向任意一个通道发送数据
    go func() {
        for i := 0; i < 10; i++ {
            // 随机暂停，模拟发送延迟
            time.Sleep(time.Millisecond * time.Duration(i*50))
            // 向任意一个可用通道发送数据i
            x := sendToAny(i, channels)
            log.Printf("Sent %v to ch%v", i, x)
        }
    }()

    // 主goroutine持续从任意一个通道接收数据
    for i := 0; i < 10; i++ {
        // 随机暂停，模拟接收延迟
        time.Sleep(time.Millisecond * time.Duration((10-i)*30))
        // 从任意一个可用通道接收数据
        v, x := recvFromAny(channels)
        log.Printf("Received %v from ch%v", v, x)
    }

    // 等待一段时间，确保所有goroutine完成
    time.Sleep(time.Second * 2)
    // 关闭所有通道
    for _, ch := range channels {
        close(ch)
    }
}