Go channel的使用场景,用法总结

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

channel的使用场景

把channel用在数据流动的地方：

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

channel的基本操作和注意事项

3种状态

nil

3种操作

读
写
关闭

9种情况

下面介绍使用channel的10种常用操作。

1. 使用for range读channel

for-range

for x := range ch{
    fmt.Println(x)
}

_,ok

oktruefalse

if v, ok := <- ch; ok {
    fmt.Println(v)
}

3. 使用select处理多个channel

select

// 分配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. 有缓冲通道可供多个协程同时处理，在一定程度可提高并发性。
用法：

// 使用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. 为操作加上超时

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")
    }
}

close(ch)

chclose(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
        }
    }
}

chan struct{}

场景：使用channel传递信号，而不是传递数据时
原理：没数据需要传递时，传递空struct
用法：

// 上例中的Handler.stopCh就是一个例子，stopCh并不需要传递任何数据
// 只是要给所有协程发送退出的信号
type Handler struct {
    stopCh chan struct{}
    reqCh chan *Request
}

10. 使用channel传递结构体的指针而非结构体

场景：使用channel传递结构体数据时
原理：channel本质上传递的是数据的拷贝，拷贝的数据越小传输效率越高，传递结构体指针，比传递结构体更高效
用法：

reqCh chan *Request
 
// 好过
reqCh chan Request

本文来自：Segmentfault