3. Channel 深度解析：无缓冲 channel、有缓冲 channel、channel 的关闭与 range 遍历、select 多路复用

Channel 是 Go 并发模型中的一等公民，是 goroutine 之间通信的核心管道。理解 channel 的底层机制、缓冲行为、生命周期管理以及多路复用模式，是构建高可靠并发系统的关键。本章从四种核心场景出发，深入剖析 channel 的设计哲学与工程实践。

3.1 无缓冲 channel：同步通信的基石

无缓冲 channel 在发送与接收之间建立严格的同步屏障。发送操作会阻塞，直到有对应的接收方就绪；接收操作同样阻塞，直到有数据到达。这种设计保证了数据传递的原子性与时序确定性。

// 无缓冲 channel 同步示例
func syncExample() {
    ch := make(chan int)
    go func() {
        result := doWork()
        ch <- result  // 发送：阻塞直到主 goroutine 接收
    }()
    value := <-ch  // 接收：阻塞直到子 goroutine 发送
    fmt.Println("收到结果:", value)
}

3.2 有缓冲 channel：异步解耦与流量调节

有缓冲 channel 在内部维护一个固定大小的环形队列。发送操作在缓冲区未满时立即返回，接收操作在缓冲区非空时立即返回。这种异步特性允许生产者和消费者以不同的速率运行，实现解耦与削峰填谷。

// 有缓冲 channel 实现工作池
func workerPoolExample() {
    jobs := make(chan int, 100)   // 缓冲 100 个任务
    results := make(chan int, 100)

    // 启动 3 个 worker
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    // 发送 10 个任务（不会阻塞，缓冲区足够）
    for j := 1; j <= 10; j++ {
        jobs <- j
    }
    close(jobs)

    // 收集结果
    for r := 1; r <= 10; r++ {
        <-results
    }
}

func worker(id int, jobs <-chan int, results chan<- int) {
    for job := range jobs {
        results <- process(job)
    }
}

3.3 Channel 的关闭与 range 遍历

关闭 channel 是向所有接收方广播“数据发送完毕”信号的标准方式。关闭后的 channel 仍然可读，但不能再写入。结合 range 关键字，可以优雅地遍历 channel 直到关闭。

// 正确的关闭与 range 遍历模式
func produce(ch chan<- int, count int) {
    for i := 0; i < count; i++ {
        ch <- i
    }
    close(ch)  // 发送方负责关闭
}

func consume(ch <-chan int) {
    for value := range ch {  // 自动检测关闭
        fmt.Println("消费:", value)
    }
    // range 退出后，channel 已关闭且无数据
}

// 手动检测关闭
func consumeWithCheck(ch <-chan int) {
    for {
        value, ok := <-ch
        if !ok {
            fmt.Println("channel 已关闭")
            break
        }
        fmt.Println("消费:", value)
    }
}

3.4 Select 多路复用：并发编排的核心模式

select 语句允许一个 goroutine 同时等待多个 channel 操作，实现多路复用。当多个 case 同时就绪时，Go 运行时随机选择一个执行，保证公平性。

// select 多路复用典型模式
func multiplexDemo() {
    ch1 := make(chan string)
    ch2 := make(chan string)
    timeout := time.After(3 * time.Second)

    go func() { ch1 <- "来自 ch1 的数据" }()
    go func() { ch2 <- "来自 ch2 的数据" }()

    select {
    case msg1 := <-ch1:
        fmt.Println("ch1 收到:", msg1)
    case msg2 := <-ch2:
        fmt.Println("ch2 收到:", msg2)
    case <-timeout:
        fmt.Println("超时：3秒无响应")
    default:
        fmt.Println("所有 channel 均未就绪")
    }
}

// 非阻塞发送/接收
func nonBlocking() {
    ch := make(chan int, 1)
    select {
    case ch <- 42:
        fmt.Println("发送成功")
    default:
        fmt.Println("channel 已满，发送失败")
    }
}

3.5 四种 channel 模式对比总结