这篇文章总结了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/03/19/channel-axioms
下面介绍使用channel的10种常用操作。
1. 使用for range读channel
- 场景：当需要不断从channel读取数据时
- 原理：使用
for-range读取channel，这样既安全又便利，当channel关闭时，for循环会自动退出，无需主动监测channel是否关闭，可以防止读取已经关闭的channel，造成读到数据为通道所存储的数据类型的零值。 - 用法：
1for x := range ch{
2 fmt.Println(x)
3}2. 使用_,ok判断channel是否关闭
- 场景：读channel，但不确定channel是否关闭时
- 原理：读已关闭的channel会造成零值 ，如果不确定channel，需要使用
ok进行检测。ok的结果和含义：- `true`：读到数据，并且通道没有关闭。
- `false`：通道关闭，无数据读到。
- 用法：
1if v, ok := <- ch; ok {
2 fmt.Println(v)
3}3. 使用select处理多个channel
- 场景：需要对多个通道进行同时处理，但只处理最先发生的channel时
- 原理：
select可以同时监控多个通道的情况，只处理未阻塞的case。当通道为nil时，对应的case永远为阻塞，无论读写。特殊关注：普通情况下，对nil的通道写操作是要panic的。 - 用法：
1// 分配job时，如果收到关闭的通知则退出，不分配job
2func (h *Handler) handle(job *Job) {
3 select {
4 case h.jobCh<-job:
5 return
6 case <-h.stopCh:
7 return
8 }
9}4. 使用channel的声明控制读写权限
- 场景：协程对某个通道只读或只写时
- 目的：A. 使代码更易读、更易维护，B. 防止只读协程对通道进行写数据，但通道已关闭，造成panic。
- 用法：
- 如果协程对某个channel只有写操作，则这个channel声明为只写。
- 如果协程对某个channel只有读操作，则这个channe声明为只读。
1// 只有generator进行对outCh进行写操作，返回声明
2// <-chan int，可以防止其他协程乱用此通道，造成隐藏bug
3func generator(int n) <-chan int {
4 outCh := make(chan int)
5 go func(){
6 for i:=0;i<n;i {
7 outCh<-i
8 }
9 }()
10 return outCh
11}
12
13// consumer只读inCh的数据，声明为<-chan int
14// 可以防止它向inCh写数据
15func consumer(inCh <-chan int) {
16 for x := range inCh {
17 fmt.Println(x)
18 }
19}5. 使用缓冲channel增强并发和异步
- 场景：异步和并发
- 原理：A. 有缓冲通道是异步的，无缓冲通道是同步的，B. 有缓冲通道可供多个协程同时处理，在一定程度可提高并发性。
- 用法：
1// 无缓冲，同步
2ch1 := make(chan int)
3ch2 := make(chan int, 0)
4// 有缓冲，异步
5ch3 := make(chan int, 1) 1// 使用5个`do`协程同时处理输入数据
2func test() {
3 inCh := generator(100)
4 outCh := make(chan int, 10)
5
6 for i := 0; i < 5; i {
7 go do(inCh, outCh)
8 }
9
10 for r := range outCh {
11 fmt.Println(r)
12 }
13}
14
15func do(inCh <-chan int, outCh chan<- int) {
16 for v := range inCh {
17 outCh <- v * v
18 }
19}6. 为操作加上超时
- 场景：需要超时控制的操作
- 原理：使用
select和time.After，看操作和定时器哪个先返回，处理先完成的，就达到了超时控制的效果 - 用法：
1func doWithTimeOut(timeout time.Duration) (int, error) {
2 select {
3 case ret := <-do():
4 return ret, nil
5 case <-time.After(timeout):
6 return 0, errors.New("timeout")
7 }
8}
9
10func do() <-chan int {
11 outCh := make(chan int)
12 go func() {
13 // do work
14 }()
15 return outCh
16}7. 使用time实现channel无阻塞读写
- 场景：并不希望在channel的读写上浪费时间
- 原理：是为操作加上超时的扩展，这里的操作是channel的读或写
- 用法：
1func unBlockRead(ch chan int) (x int, err error) {
2 select {
3 case x = <-ch:
4 return x, nil
5 case <-time.After(time.Microsecond):
6 return 0, errors.New("read time out")
7 }
8}
9
10func unBlockWrite(ch chan int, x int) (err error) {
11 select {
12 case ch <- x:
13 return nil
14 case <-time.After(time.Microsecond):
15 return errors.New("read time out")
16 }
17}注：time.After等待可以替换为default，则是channel阻塞时，立即返回的效果
8. 使用close(ch)关闭所有下游协程
- 场景：退出时，显示通知所有协程退出
- 原理：所有读
ch的协程都会收到close(ch)的信号 - 用法：
1func (h *Handler) Stop() {
2 close(h.stopCh)
3
4 // 可以使用WaitGroup等待所有协程退出
5}
6
7// 收到停止后，不再处理请求
8func (h *Handler) loop() error {
9 for {
10 select {
11 case req := <-h.reqCh:
12 go handle(req)
13 case <-h.stopCh:
14 return
15 }
16 }
17}9. 使用chan struct{}作为信号channel
- 场景：使用channel传递信号，而不是传递数据时
- 原理：没数据需要传递时，传递空struct
- 用法：
1// 上例中的Handler.stopCh就是一个例子，stopCh并不需要传递任何数据
2// 只是要给所有协程发送退出的信号
3type Handler struct {
4 stopCh chan struct{}
5 reqCh chan *Request
6}10. 使用channel传递结构体的指针而非结构体
- 场景：使用channel传递结构体数据时
- 原理：channel本质上传递的是数据的拷贝，拷贝的数据越小传输效率越高，传递结构体指针，比传递结构体更高效
- 用法：
1reqCh chan *Request
2
3// 好过
4reqCh chan Request
