2. Channel通信：无缓冲channel、有缓冲channel、关闭channel与range遍历

Channel 是 Go 并发模型中的一等公民，也是 goroutine 之间传递消息与同步执行的核心原语。CSP（Communicating Sequential Processes）模型在 Go 中的落地，正是通过 channel 实现“不通过共享内存来通信，而是通过通信来共享内存”。本章从三种 channel 形态出发，结合关闭与遍历机制，深入剖析其底层行为与调优要点。

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

无缓冲 channel 在创建时不指定容量，其本质是一个同步管道：发送操作会阻塞，直到有对应的接收操作就绪；接收操作同样会阻塞，直到有发送方写入。这种“握手”机制保证了两个 goroutine 在数据交换点严格同步。

// 无缓冲 channel 示例：goroutine 同步
func main() {
    ch := make(chan int) // 无缓冲

    go func() {
        // 模拟耗时计算
        time.Sleep(100 * time.Millisecond)
        ch <- 42 // 发送：阻塞直到 main goroutine 接收
    }()

    result := <-ch // 接收：阻塞直到子 goroutine 发送
    fmt.Println(result) // 输出 42
}

无缓冲 channel 的阻塞特性天然适合做 goroutine 间的“栅栏”或“交接点”。在中间件链路中，常用于控制多个初始化任务的完成顺序，或作为限流信号量（配合 select 实现非阻塞尝试）。

2.2 有缓冲 channel：异步队列与吞吐优化

有缓冲 channel 在创建时指定容量，允许发送方在缓冲区未满时直接写入而不阻塞，接收方在缓冲区非空时直接读取而不阻塞。缓冲区的存在解耦了发送与接收的时序，提升了系统的吞吐能力。

// 有缓冲 channel 示例：生产者-消费者模式
func main() {
    ch := make(chan int, 3) // 缓冲区容量为 3

    // 生产者：可以连续发送 3 次而不阻塞
    ch <- 1
    ch <- 2
    ch <- 3
    // ch <- 4 // 如果取消注释，第 4 次发送会阻塞

    // 消费者
    fmt.Println(<-ch) // 1
    fmt.Println(<-ch) // 2
    fmt.Println(<-ch) // 3
}

2.3 关闭 channel：优雅终止与信号广播

关闭 channel 是 Go 中通知接收方“不再有数据发送”的标准方式。关闭后的 channel 具有以下行为：

• 发送：向已关闭的 channel 发送数据会触发 panic。
• 接收：从已关闭的 channel 接收数据会立即返回零值，且第二个返回值（ok）为 false。
• 多次关闭：重复关闭同一个 channel 会触发 panic。
• 广播：所有阻塞在接收操作的 goroutine 都会收到关闭信号（零值 + false）。

// 关闭 channel 的正确模式
func producer(ch chan<- int) {
    for i := 0; i < 5; i++ {
        ch <- i
    }
    close(ch) // 发送完毕，关闭 channel
}

func consumer(ch <-chan int) {
    for {
        val, ok := <-ch
        if !ok {
            fmt.Println("channel 已关闭，退出")
            break
        }
        fmt.Println("收到:", val)
    }
}

func main() {
    ch := make(chan int, 3)
    go producer(ch)
    consumer(ch)
}

2.4 range 遍历：自动检测 channel 关闭

for range 是遍历 channel 最简洁的方式，它会自动从 channel 中接收数据，直到 channel 被关闭且缓冲区为空。相比手动 for { val, ok := <-ch } 模式，range 写法更安全、更不易遗漏关闭检测。

// 使用 range 遍历 channel
func main() {
    ch := make(chan string, 2)
    ch <- "hello"
    ch <- "world"
    close(ch)

    for msg := range ch {
        fmt.Println(msg) // 依次输出 "hello" 和 "world"
    }
    // range 结束后自动退出，无需手动 break
}

range 遍历的底层等价于不断调用 <-ch 并检查 ok 标志。当 channel 未关闭且无数据时，range 会阻塞等待。因此，使用 range 遍历的 goroutine 必须确保 channel 最终会被关闭，否则会导致 goroutine 泄漏。

2.5 三种 channel 形态对比与选择

以下 SVG 图展示了无缓冲 channel、有缓冲 channel 和已关闭 channel 在发送/接收时的状态机与数据流路径，帮助理解不同形态下的 goroutine 调度行为。

2.6 实战：goroutine 池中的 channel 通信模式

在中间件链路开发中，goroutine 池（worker pool）是最常见的 channel 应用场景。以下是一个基于有缓冲 channel 和关闭机制的 worker pool 实现：

// Worker Pool 实现：任务分发与结果收集
type Task struct {
    ID   int
    Data string
}

type Result struct {
    TaskID int
    Output string
}

func worker(id int, tasks <-chan Task, results chan<- Result) {
    for task := range tasks { // 自动检测 tasks 关闭
        // 模拟处理
        time.Sleep(50 * time.Millisecond)
        results <- Result{
            TaskID: task.ID,
            Output: fmt.Sprintf("worker %d processed: %s", id, task.Data),
        }
    }
}

func main() {
    numWorkers := 5
    taskCh := make(chan Task, 100)
    resultCh := make(chan Result, 100)

    // 启动 worker goroutine
    var wg sync.WaitGroup
    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            worker(id, taskCh, resultCh)
        }(i)
    }

    // 发送任务
    for i := 0; i < 20; i++ {
        taskCh <- Task{ID: i, Data: fmt.Sprintf("task-%d", i)}
    }
    close(taskCh) // 通知所有 worker 不再有任务

    // 等待所有 worker 完成
    wg.Wait()
    close(resultCh) // 所有结果已收集完毕

    // 收集结果
    for res := range resultCh {
        fmt.Println(res.Output)
    }
}

2.7 常见陷阱与避坑指南