总结了才知道,原来channel有这么多用法!

43

这篇文章总结了channel的10种常用操作,以一个更高的视角看待channel,会给大家带来对channel更全面的认识。

在介绍10种操作前,先简要介绍下channel的使用场景、基本操作和注意事项。

channel的使用场景

把channel用在数据流动的地方

  1. 消息传递、消息过滤
  2. 信号广播
  3. 事件订阅与广播
  4. 请求、响应转发
  5. 任务分发
  6. 结果汇总
  7. 并发控制
  8. 同步与异步
  9. ...

channel的基本操作和注意事项

channel存在3种状态

  1. nil,未初始化的状态,只进行了声明,或者手动赋值为nil
  2. active,正常的channel,可读或者可写
  3. closed,已关闭,千万不要误认为关闭channel后,channel的值是nil

channel可进行3种操作

  1. 关闭

把这3种操作和3种channel状态可以组合出9种情况

操作 nil的channel 正常channel 已关闭channel
<- ch 阻塞 成功或阻塞 读到零值
ch <- 阻塞 成功或阻塞 panic
close(ch) panic 成功 panic

对于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会得到零值,如果不确定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增强并发

  • 场景:并发
  • 原理:有缓冲通道可供多个协程同时处理,在一定程度可提高并发性。
  • 用法:
// 无缓冲
ch1 := make(chan int)
ch2 := make(chan int, 0)
// 有缓冲
ch3 := make(chan int, 1)
func test() {
    inCh := generator(100)
    outCh := make(chan int, 10)

    // 使用5个`do`协程同时处理输入数据
    var wg sync.WaitGroup
    wg.Add(5)
    for i := 0; i < 5; i++ {
        go do(inCh, outCh, &wg)
    }

    go func() {
        wg.Wait()
        close(outCh)
    }()

    for r := range outCh {
        fmt.Println(r)
    }
}

func generator(n int) <-chan int {
    outCh := make(chan int)
    go func() {
        for i := 0; i < n; i++ {
            outCh <- i
        }
        close(outCh)
    }()
    return outCh
}

func do(inCh <-chan int, outCh chan<- int, wg *sync.WaitGroup) {
    for v := range inCh {
        outCh <- v * v
    }

    wg.Done()
}

6. 为操作加上超时

  • 场景:需要超时控制的操作
  • 原理:使用selecttime.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

11. 使用channel传递channel

  • 场景:使用场景有点多,通常是用来获取结果。
  • 原理:channel可以用来传递变量,channel自身也是变量,可以传递自己。
  • 用法:下面示例展示了有序展示请求的结果,另一个示例可以见另外文章的版本3
package main

import (
    "fmt"
    "math/rand"
    "sync"
    "time"
)

func main() {
    reqs := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}

    // 存放结果的channel的channel
    outs := make(chan chan int, len(reqs))
    var wg sync.WaitGroup
    wg.Add(len(reqs))
    for _, x := range reqs {
        o := handle(&wg, x)
        outs <- o
    }

    go func() {
        wg.Wait()
        close(outs)
    }()

    // 读取结果,结果有序
    for o := range outs {
        fmt.Println(<-o)
    }
}

// handle 处理请求,耗时随机模拟
func handle(wg *sync.WaitGroup, a int) chan int {
    out := make(chan int)
    go func() {
        time.Sleep(time.Duration(rand.Intn(3)) * time.Second)
        out <- a
        wg.Done()
    }()
    return out
}

你有哪些channel的奇淫巧技,说来看看?

  1. 如果这篇文章对你有帮助,请点个赞/喜欢,感谢
  2. 本文作者:大彬
  3. 如果喜欢本文,随意转载,但请保留此原文链接:http://lessisbetter.site/2019/01/20/golang-channel-all-usage/


如果觉得我的文章对你有用,请随意赞赏

你可能感兴趣的

16 条评论
LiamPayne · 2月1日

楼主只读/只写channel部分是不是有笔误呢?

回复

0

眼戳,没看出来,请具体说下哪里

大彬 作者 · 2月1日
0

只写通道:chan<- T
只读通道:<-chan T

我看你写的两个都一样了
不过楼主总结的真好,学习了

LiamPayne · 2月1日
0

@LiamPayne 没毛病,示例代码都是只读的

大彬 作者 · 2月1日
yeqown · 3月1日

第5点中,把“同步异步”和“阻塞非阻塞”概念混淆了哦.

回复

0

有道理,同步异步取决于逻辑实现,阻塞和非阻塞也取决于对channel的操作方式,不仅仅是缓冲区

大彬 作者 · 3月2日
fox_lin · 3月31日

实测case5中,test中for range读channel会引起test所在的routine发生deadlock

回复

0

已补全代码

大彬 作者 · 4月2日
0

@大彬 5个routine共用一个输出channel,什么时候close这个输出channel就很重要了,你这方法好。

fox_lin · 4月2日
0

@fox_lin 对,多个写channel的goroutine结束后才能关闭

大彬 作者 · 4月4日
ivloli · 6月6日

还有一种用法,用于队列数据处理的保序。假设一个channel里面是待处理的数据,然后需要并行处理其中的数据并输出,并且保证输出顺序和原始channel顺序一致。可以采用这种方法:
协程处理函数:
加锁->取数据->将一个新channel chan1放进输出channel中(这个输出channel的元素也是channel,类型就是新channel类型)->解锁,处理数据->数据放进chan1中
消费函数:
从输出channel中读取元素,这些元素都是channel类型,然后从其中拿出真正的结果进行消费。
以下代码仅做演示,不保证语法逻辑正确

var mutex sync.Mutex
func do(in <-chan int, out chan<- chan int, ctx context.Context){

for {
    select{
        case <-ctx.Done():
            return
        default:
            mutex.Lock
            if a,ok := <-in;ok == false{
                               mutex.Unlock
                               return
                            }
            ch := make(chan int)//这里可以考虑用资源池等,减少GC压力
            out<- ch
            mutex.Unlock
            //do sth with the value a
            //get result
            result := realworker(a)
            ch<- result
    }
}

}
func main(){

for i:=0;i<=WORKERS;i++{
    go do(input,output,ctx)
}

for v := range out{
    value := <-v
    consumer(value)
}

}

回复

0

Great,使用channel传递channel的场景,我可以补充进来。

大彬 作者 · 6月6日
haozibi · 6月27日

示例 “2 使用_,ok判断channel是否关闭 ” 表达的不是很准确,对 ok 返回值的认识是比较片面的。

ok 表示接收到的值是否是在 channel 被关闭前发送的,并不是 channel 是否关闭的标志

我的示例: https://play.golang.org/p/LuT...

回复

0

谢谢指正

大彬 作者 · 6月28日
0

@大彬 看了你的 golang-first-class-function 受益匪浅,谢谢

haozibi · 6月28日
0
大彬 作者 · 9月9日
载入中...