Go语言channel用法总结

channel的基本操作和注意事项

channel存在3种状态：

• nil，未初始化的状态，只进行了声明，或者手动赋值为nil
• active，正常的channel，可读或者可写
• closed，已关闭，关闭的channel并不是nil状态的channel

channel可进行的操作

• 读
• 写
• 关闭

3种状态结合3种操作，9种情况

对于nil通道的情况，也并非完全遵循上表，有1个特殊场景：当nil的通道在select的某个case中时，这个case会阻塞，但不会造成死锁。

channel的十种常用操作

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进行处理，但只需要处理最先发生的channel时
• 原理：select可以同时检测多个channel的情况，只处理未阻塞的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的声明控制读写权限

• 场景：协程对某个通道只读或者只写时
• 目的：①使代码更易读易维护；②防止只读协程对通道进行写数据，但通道已关闭，造成pannic。
• 用法：①.如果协程对某个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.使用缓冲通道增强并发

• 场景：并发
• 原理：有缓冲通道可供多个协程同时处理，在一定程度可提高并发性。
• 用法：

  // 无缓冲
  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()
  }

  待续。。。