这篇文章总结了 channel 的 10 种常用操作，以一个更高的视角看待 channel，会给大家带来对 channel 更全面的认识。
在介绍 10 种操作前，先简要介绍下 channel 的使用场景、基本操作和注意事项。
channel 的使用场景
把 channel 用在数据流动的地方：
消息传递、消息过滤
信号广播
事件订阅与广播
请求、响应转发
任务分发
结果汇总
并发控制
同步与异步
…
channel 的基本操作和注意事项
channel 存在 3 种状态：
nil，未初始化的状态，只进行了声明，或者手动赋值为 nil
active，正常的 channel，可读或者可写
closed，已关闭，千万不要误认为关闭 channel 后，channel 的值是 nil
channel 可进行 3 种操作：
读
写
关闭
把这 3 种操作和 3 种 channel 状态可以组合出 9 种情况：
对于 nil 通道的情况，也并非完全遵循上表，有 1 个特殊场景：当 nil 的通道在 select 的某个 case 中时，这个 case 会阻塞，但不会造成死锁。
参考代码请看：https://dave.cheney.net/2014/…
下面介绍使用 channel 的 10 种常用操作。
1. 使用 for range 读 channel
场景：当需要不断从 channel 读取数据时
原理：使用 for-range 读取 channel，这样既安全又便利，当 channel 关闭时，for 循环会自动退出，无需主动监测 channel 是否关闭，可以防止读取已经关闭的 channel，造成读到数据为通道所存储的数据类型的零值。
用法：
for x := range ch{
fmt.Println(x)
}
2. 使用_,ok 判断 channel 是否关闭
场景：读 channel，但不确定 channel 是否关闭时
原理：读已关闭的 channel 会造成 panic，如果不确定 channel，需要使用 ok 进行检测。ok 的结果和含义：
true：读到数据，并且通道没有关闭。
false：通道关闭，无数据读到。
用法：
if v, ok := <- ch; ok {
fmt.Println(v)
}
3. 使用 select 处理多个 channel
场景：需要对多个通道进行同时处理，但只处理最先发生的 channel 时
原理：select 可以同时监控多个通道的情况，只处理未阻塞的 case。当通道为 nil 时，对应的 case 永远为阻塞，无论读写。特殊关注：普通情况下，对 nil 的通道写操作是要 panic 的。
用法：
// 分配 job 时，如果收到关闭的通知则退出，不分配 job
func (h *Handler) handle(job *Job) {
select {
case h.jobCh<-job:
return
case <-h.stopCh:
return
}
}
4. 使用 channel 的声明控制读写权限
场景：协程对某个通道只读或只写时
目的：A. 使代码更易读、更易维护，B. 防止只读协程对通道进行写数据，但通道已关闭，造成 panic。
用法：
如果协程对某个 channel 只有写操作，则这个 channel 声明为只写。
如果协程对某个 channel 只有读操作，则这个 channe 声明为只读。
// 只有 generator 进行对 outCh 进行写操作，返回声明
// <-chan int，可以防止其他协程乱用此通道，造成隐藏 bug
func generator(int n) <-chan int {
outCh := make(chan int)
go func(){
for i:=0;i<n;i++{
outCh<-i
}
}()
return outCh
}
// consumer 只读 inCh 的数据，声明为 <-chan int
// 可以防止它向 inCh 写数据
func consumer(inCh <-chan int) {
for x := range inCh {
fmt.Println(x)
}
}
5. 使用缓冲 channel 增强并发和异步
场景：异步和并发
原理：A. 有缓冲通道是异步的，无缓冲通道是同步的，B. 有缓冲通道可供多个协程同时处理，在一定程度可提高并发性。
用法：
// 无缓冲，同步
ch1 := make(chan int)
ch2 := make(chan int, 0)
// 有缓冲，异步
ch3 := make(chan int, 1)
// 使用 5 个 `do` 协程同时处理输入数据
func test() {
inCh := generator(100)
outCh := make(chan int, 10)
for i := 0; i < 5; i++ {
go do(inCh, outCh)
}
for r := range outCh {
fmt.Println(r)
}
}
func do(inCh <-chan int, outCh chan<- int) {
for v := range inCh {
outCh <- v * v
}
}
6. 为操作加上超时
场景：需要超时控制的操作
原理：使用 select 和 time.After，看操作和定时器哪个先返回，处理先完成的，就达到了超时控制的效果
用法：
func doWithTimeOut(timeout time.Duration) (int, error) {
select {
case ret := <-do():
return ret, nil
case <-time.After(timeout):
return 0, errors.New(“timeout”)
}
}
func do() <-chan int {
outCh := make(chan int)
go func() {
// do work
}()
return outCh
}
7. 使用 time 实现 channel 无阻塞读写
场景：并不希望在 channel 的读写上浪费时间
原理：是为操作加上超时的扩展，这里的操作是 channel 的读或写
用法：
func unBlockRead(ch chan int) (x int, err error) {
select {
case x = <-ch:
return x, nil
case <-time.After(time.Microsecond):
return 0, errors.New(“read time out”)
}
}
func unBlockWrite(ch chan int, x int) (err error) {
select {
case ch <- x:
return nil
case <-time.After(time.Microsecond):
return errors.New(“read time out”)
}
}
注：time.After 等待可以替换为 default，则是 channel 阻塞时，立即返回的效果
8. 使用 close(ch) 关闭所有下游协程
场景：退出时，显示通知所有协程退出
原理：所有读 ch 的协程都会收到 close(ch) 的信号
用法：
func (h *Handler) Stop() {
close(h.stopCh)
// 可以使用 WaitGroup 等待所有协程退出
}
// 收到停止后，不再处理请求
func (h *Handler) loop() error {
for {
select {
case req := <-h.reqCh:
go handle(req)
case <-h.stopCh:
return
}
}
}
9. 使用 chan struct{} 作为信号 channel
场景：使用 channel 传递信号，而不是传递数据时
原理：没数据需要传递时，传递空 struct
用法：
// 上例中的 Handler.stopCh 就是一个例子，stopCh 并不需要传递任何数据
// 只是要给所有协程发送退出的信号
type Handler struct {
stopCh chan struct{}
reqCh chan *Request
}
10. 使用 channel 传递结构体的指针而非结构体
场景：使用 channel 传递结构体数据时
原理：channel 本质上传递的是数据的拷贝，拷贝的数据越小传输效率越高，传递结构体指针，比传递结构体更高效
用法：
reqCh chan *Request
// 好过
reqCh chan Request
你有哪些 channel 的奇淫巧技，说来看看？
如果这篇文章对你有帮助，请点个赞 / 喜欢，感谢。
本文作者：大彬
如果喜欢本文，随意转载，但请保留此原文链接：http://lessisbetter.site/2019/01/20/golang-channel-all-usage/