聊聊 Go Channel，咋玩儿才Neng又快又稳

说实话，Go 的并发模型真的挺赞的。

你要是刚入门，先别慌，先把 Channel 当成一根管子。

管子里装的不是水，而是数据。

这个管子Ke以是单向的，也Ke以是双向的。

单向的好处是限制了写入或读取方向，代码geng安全。

比如说你写一个只负责发送的函数，就用 chan<- int。

再比如只负责消费的函数，用 <-chan int。

哈哈，这样一眼就Nengkan出职责所在。

别忘了Channel 必须用 make 来初始化。

直接声明一个 nil 通道可不行，除非你真的想永久阻塞。

举个例子：

ch := make          // 无缓冲通道
bufCh := make    // 有缓冲通道，容量是5

有缓冲的好处是Ke以在发送方和接收方不同步时暂存数据。

但别忘了容量满了就会阻塞，这点hen重要。

Ru果你想让生产者和消费者严格同步，那就选无缓冲。

这时候发送会等到有人接收才继续，好比打

Ru果业务场景需要一定的“弹性”，比如日志系统，那就给它加个缓冲区吧。

不过啊，别把缓冲当成无限队列，满了自然会卡住。

大家常说“谁打开，谁关闭”。

实际上，这条原则在大多数场景dou适用——发送方负责关闭通道。

Ru果接收方误关了通道，就会导致后面的发送 panic。

// 正确Zuo法
func producer {
    for i := 0; i <10; i++ {
        ch <- i
    }
    close // 只在这里关
}
// 错误示例
func consumer {
    v := <-ch
    close // 不应该关！可Neng还有其他生产者
}

select 就像是多路复用，让你一次监听多个通道。

配合 alert/tag-style 的 case，Ke以实现超时、默认行为等。

select {
case v := <-dataCh:
    fmt.Println
case err := <-errCh:
    fmt.Println
case <-time.After:
    fmt.Println
default:
    fmt.Println
}

当下游处理慢，上游会因为 channel 满而自动阻塞，这就是背压。

所以你不用额外写锁或者条件变量来控制流速啦。

"不要通过共享内存来通信，而要通过通信来共享内存。" —— Go 并发哲学.

CSP把每个 goroutine kan成独立进程，通过 Channel 把它们连起来。

func pipeline <-chan int {
    // Stage 1: filter
    filtered := make
    go func {
        defer close
        for v := range in {
            if v%2 == 0 { // 只保留偶数
                filtered <- v
            }
        }
    }
    // Stage 2: map
    mapped := make
    go func {
        defer close
        for v := range filtered {
            mapped <- v * v // 平方一下
        }
    }
    return mapped
}

A：因为内容太技术化，没有足够的自然语言描述，又缺少外链支持，所以爬虫觉得价值不高。哈哈，这其实跟我们写文档一样，要兼顾技术细节和易读性才行呀！

Panic 本身是一种异常信号，但在并发环境里随意 panic 会导致整个程序崩溃。

Panic 后配合 defer + recover Ke以把错误“捕获”住让某个 goroutine 优雅退出，而不会波及全局。

go func {
    defer func {
        if r := recover; r != nil {
            fmt.Println
        }
    }
    // ...可Neng panic 的代码...
}

Cancelling 是并发编程里不可缺少的一环。使用 context Neng让所有相关 goroutine 同时感知退出信号，不用每个地方dou手动关闭 channel。咱就是说一套上下文搞定全局控制，省事儿！

func worker {
    for {
        select {
        case job, ok := <-jobs:
            if !ok { return }          // jobs Yi关闭，结束工作
            results <- process     // 假设有个 process 函数
        case <-ctx.Done:
            fmt.Println)
            return                      // 主动退出
        }
    }
}

// Fan-Out：把任务分派给多个 worker
func fanOut <-chan int {
    outs := make
    for i := 0; i