Go 通道：无缓冲通道与缓冲通道

Go 语言的通道（channel）是协程（goroutine）之间通信的桥梁。它像一条传送带，一端发送数据，另一端接收数据。根据是否内置存储空间，通道分为无缓冲通道和缓冲通道。理解两者的区别，能避免死锁、提升程序性能。

无缓冲通道：同步通信

创建一个无缓冲通道：

ch := make(chan int)

无缓冲通道没有内部存储空间。这意味着 发送操作会阻塞，直到有另一个协程执行 接收操作；反之亦然。这种“你发我收，同时发生”的机制称为同步通信。

运行以下代码观察行为：

package main

import "fmt"

func main() {
    ch := make(chan int)
    go func() {
        fmt.Println("准备发送数据")
        ch <- 42 // 发送操作会阻塞，直到有人接收
        fmt.Println("数据已发送")
    }()
    fmt.Println("准备接收数据")
    val := <-ch // 接收操作
    fmt.Println("接收到:", val)
}

输出顺序为：

准备接收数据
准备发送数据
数据已发送
接收到: 42

关键点在于：ch <- 42 这行不会立即完成，必须等到 <-ch 执行时才“配对成功”。如果主协程不接收，发送协程将永远卡住，导致死锁。

避免死锁的规则：确保每个发送操作都有对应的接收者，且两者在不同协程中运行。

缓冲通道：异步通信

创建一个缓冲通道：

ch := make(chan int, 3) // 容量为3

缓冲通道内部有一个固定大小的队列。只要队列未满，发送操作不会阻塞；只要队列非空，接收操作也不会阻塞。这种“先存后取”的机制称为异步通信。

运行以下代码：

package main

import "fmt"

func main() {
    ch := make(chan int, 2)
    ch <- 10 // 不阻塞，队列有空间
    ch <- 20 // 不阻塞，队列还有空间
    fmt.Println("两个值已发送")
    fmt.Println(<-ch) // 输出10
    fmt.Println(<-ch) // 输出20
}

输出：

两个值已发送
10
20

注意：当尝试发送第3个值（ch <- 30）时，由于缓冲区容量为2，该操作会阻塞，直到有人从通道中取出一个值。

核心区别对比

如何选择？

使用无缓冲通道当你需要：

• 确保发送和接收动作严格同步。
• 实现协程间的“握手”机制，例如通知某个任务已完成。

示例：等待所有工作协程结束

package main

import (
    "fmt"
    "sync"
)

func worker(id int, done chan bool) {
    fmt.Printf("Worker %d 开始\n", id)
    // 模拟工作
    done <- true // 通知完成
}

func main() {
    done := make(chan bool)
    var wg sync.WaitGroup
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            worker(id, done)
        }(i)
    }
    go func() {
        wg.Wait()
        close(done) // 所有工作完成后关闭通道
    }()
    for range done {
        // 接收每个完成信号
    }
    fmt.Println("所有工作完成")
}

使用缓冲通道当你需要：

• 允许生产者暂时快于消费者。
• 避免因瞬时速度不匹配导致的阻塞。

示例：日志收集器

package main

import (
    "fmt"
    "time"
)

func logger(messages chan string) {
    for msg := range messages {
        fmt.Println("记录日志:", msg)
        time.Sleep(100 * time.Millisecond) // 模拟写入延迟
    }
}

func main() {
    messages := make(chan string, 10) // 缓冲10条
    go logger(messages)
    for i := 1; i <= 15; i++ {
        messages <- fmt.Sprintf("消息 %d", i) // 前10条立即入队，后5条稍等
    }
    close(messages)
    time.Sleep(2 * time.Second) // 等待日志处理完
}

常见陷阱与规避方法

1. 向已关闭的通道发送数据
   会导致 panic。确保只在确定不再有发送者时才关闭通道。

2. 从已关闭的通道接收
   会立即返回零值，并且第二个返回值为 false。使用多值赋值判断通道是否关闭：

   if val, ok := <-ch; ok {
       // 通道未关闭，val 有效
   } else {
       // 通道已关闭
   }

3. 忘记关闭通道导致死循环
   在使用 for range 遍历通道时，必须关闭通道，否则循环永不结束。

4. 缓冲区过大浪费内存
   根据实际吞吐量设置合理容量，避免过度分配。

检查通道状态

获取通道的缓冲区剩余容量：

cap(ch) // 返回通道总容量
len(ch) // 返回当前队列中元素数量

注意：len 和 cap 在并发环境下不是原子操作，仅用于调试或监控，不要用于逻辑判断。

性能考量

无缓冲通道涉及协程调度切换，开销略高；缓冲通道在缓冲区未满/空时无需调度，性能更好。但差别通常微乎其微，优先考虑程序正确性而非微优化。

测试通道类型对性能的影响：

package main

import (
    "testing"
)

func BenchmarkUnbuffered(b *testing.B) {
    for i := 0; i < b.N; i++ {
        ch := make(chan int)
        go func() { ch <- 1 }()
        <-ch
    }
}

func BenchmarkBuffered(b *testing.B) {
    for i := 0; i < b.N; i++ {
        ch := make(chan int, 1)
        ch <- 1
        <-ch
    }
}

运行 go test -bench=. 可观察差异，但实际应用中瓶颈极少在此。

选择无缓冲还是缓冲，本质是在“控制精度”和“执行效率”之间权衡。明确你的协程协作模型，就能做出正确决策。