Go语言并发编程：动态监听N个Channel的实现策略

c1 := make(chan string)
c2 := make(chan string)

go DoStuff(c1, 5) // DoStuff是一个模拟向Channel发送消息的函数
go DoStuff(c2, 2)

for { // 无限循环监听
    select {
    case msg1 := <-c1:
        fmt.Println("Received from c1:", msg1)
        // 可以在这里启动新的goroutine或执行其他逻辑
    case msg2 := <-c2:
        fmt.Println("Received from c2:", msg2)
        // 可以在这里启动新的goroutine或执行其他逻辑
    }
}

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

type SelectCase struct {
    Dir  SelectDir   // 操作方向：发送、接收或默认
    Chan Value       // 参与操作的Channel
    Send Value       // 如果是发送操作，要发送的值
}

package main

import (
    "fmt"
    "reflect"
    "strconv"
    "time"
)

// DoStuff 模拟一个goroutine，周期性地向指定Channel发送消息
// ch: 要发送消息的Channel
// id: 标识符，用于区分不同的Channel和消息源
func DoStuff(ch chan string, id int) {
    for i := 0; ; i++ {
        // 模拟不同的工作负载，导致发送间隔不同
        time.Sleep(time.Duration(id) * 100 * time.Millisecond)
        msg := fmt.Sprintf("消息 %d 来自 Channel %d", i, id)
        ch <- msg // 向Channel发送消息
    }
}

func main() {
    numChans := 3 // 示例：动态创建并监听3个Channel

    // 用于存储所有Channel的切片
    var chans []chan string

    // 创建指定数量的Channel，并为每个Channel启动一个发送消息的goroutine
    for i := 0; i < numChans; i++ {
        tmpChan := make(chan string)
        chans = append(chans, tmpChan)
        go DoStuff(tmpChan, i+1) // 启动一个goroutine向此Channel发送数据
    }

    fmt.Printf("开始动态监听 %d 个 Channel...\n", numChans)

    for { // 无限循环，持续进行动态select操作
        // 1. 构建 reflect.SelectCase 切片
        // 每次循环都需要重新构建，因为chosen、value等是根据当前状态决定的
        cases := make([]reflect.SelectCase, len(chans))
        for i, ch := range chans {
            cases[i] = reflect.SelectCase{
                Dir:  reflect.SelectRecv,        // 操作方向：接收
                Chan: reflect.ValueOf(ch),       // 包装Channel为reflect.Value
            }
        }

        // 2. 执行 reflect.Select 操作
        // chosen: 被选中的case的索引
        // value: 接收到的值 (reflect.Value类型)
        // ok: 如果Channel未关闭则为true，否则为false
        chosen, value, ok := reflect.Select(cases)

        // 3. 处理 select 结果
        if ok { // Channel未关闭，成功接收到消息
            receivedMsg := value.String() // 将reflect.Value转换为string
            chosenChannelIndex := chosen
            fmt.Printf("在 %s 收到消息：'%s' 来自 Channel 索引 %d\n",
                time.Now().Format("15:04:05"), receivedMsg, chosenChannelIndex)

            // 原始问题中提到在接收后启动新的goroutine。
            // 如果需要在此处根据接收到的消息启动新的任务，可以这样做：
            // go SomeNewTask(chans[chosenChannelIndex], receivedMsg)
            // 注意：如果原有的DoStuff goroutine仍在运行，且这里又启动一个向相同Channel发送的goroutine，
            // 可能会导致Channel写入方过多。实际应用中需谨慎设计。

        } else { // Channel已关闭
            // 在实际应用中，当Channel关闭时，通常需要将其从监听列表中移除，
            // 以避免重复选择一个已关闭的Channel。
            // 这里为了简化示例，我们直接退出循环。
            fmt.Printf("Channel 索引 %d 已关闭。停止监听。\n", chosen)
            break // 退出监听循环
        }

        // 短暂延迟，避免在某些极端情况下（例如所有Channel都快速关闭）导致CPU空转
        time.Sleep(10 * time.Millisecond)
    }

    fmt.Println("动态Channel监听器已停止。")
}