这篇文章总结了channel的10种常用操作,以一个更高的视角看待channel,会给大家带来对channel更全面的认识。
在介绍10种操作前,先简要介绍下channel的使用场景、基本操作和注意事项。
把channel用在数据流动的地方:
channel存在3种状态
:
nil
channel可进行3种操作
:
把这3种操作和3种channel状态可以组合出9种情况
:
对于nil通道的情况,也并非完全遵循上表,有1个特殊场景:当nil
的通道在select
的某个case
中时,这个case会阻塞,但不会造成死锁。
参考代码请看:https://dave.cheney.net/2014/03/19/channel-axioms
下面介绍使用channel的10种常用操作。
for-range
读取channel,这样既安全又便利,当channel关闭时,for循环会自动退出,无需主动监测channel是否关闭,可以防止读取已经关闭的channel,造成读到数据为通道所存储的数据类型的零值。1for x := range ch{
2 fmt.Println(x)
3}
ok
进行检测。ok的结果和含义:1if v, ok := <- ch; ok {
2 fmt.Println(v)
3}
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}
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}
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}
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}
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阻塞时,立即返回的效果
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}
1// 上例中的Handler.stopCh就是一个例子,stopCh并不需要传递任何数据
2// 只是要给所有协程发送退出的信号
3type Handler struct {
4 stopCh chan struct{}
5 reqCh chan *Request
6}
1reqCh chan *Request
2
3// 好过
4reqCh chan Request