Question

• 在一个函数调用前加上“go”关键词，那么本地调用就会在一个新的goroutine 中并发执行

  • 如果该函数有返回值，则会被抛弃
  • 函数结束，goroutine 也会结束

• 不要通过共享内存来通信，而应该通过通信来共享内存

• go通过消息机制而非共享内存作为并发单元间的通信方式，这个消息机制在go中被称为channel

• 消息机制认为每一个并发单元都是一个自包含、独立的个体，并且有自己不共享的变量。

• 每个并发单元的输入输出都只能是消息。

• channel是go在语言级别为goroutine 间的通信方式

• channel是类型相关的，一个channel只能传递一种类型的值

• channel语法

  • 声明

    • var a chan int：声明一个传递类型为int的channel
    • var b map[string] chan bool ：声明了一个map，元素是bool类型的channel

  • 初始化

    • a := make(chan int)：声明并初始化一个int类型名为a的channel

  • 读取与写入

    • a <- 1 ：将1写入名为a的channel
    • value := <- a：从名为a的channel中读取数据到value中

  • 设置限制大小带有缓冲的channel

    • 在需要传输大量数据的场景下，传递单个数据的channel就不合适啦
    • ch := make(chan init ,1024)：声明并创建一个大小1024的int类型的channel
    • 在没有读取方的时候，写入方可以一直写，直到填充完channel前都不会阻塞

• 单向只读只写channel

  • 默认情况下，通道 channel 是双向的，也就是，既可以往里面发送数据也可以同里面接收数据。但是，我们经常见一个通道作为参数进行传递而只希望对方是单向使用的，要么只让它发送数据，要么只让它接收数据，这时候我们可以指定通道的方向。而所谓的单向channel，可以理解为对channel的限制。例如限制某个函数只能往某个channel中写入数据

  • 如果直接使用make创建单向channel（ch := make(<-chan int))，就毫无意义。通常声明初始化一个正常双向的channel，再使用类型转换创建单向的

    ch := make(chan int)
    // 声明一个只能写入数据的通道类型, 并赋值为ch
    var chSendOnly chan<- int = ch
    //声明一个只能读取数据的通道类型, 并赋值为ch
    var chRecvOnly <-chan int = ch
    

    func producer(out chan<- int)  {
      for i:= 0; i < 10; i++ {
         out <- i*i                // 将 i*i 结果写入到只写channel
      }
      close(out)
    }
    // 此通道只能读，不能写
    func consumer(in <-chan int)  {
      for num := range in {        // 从只读channel中获取数据
         fmt.Println("num =", num)
      }
    }
    func main()  {
      ch := make(chan int)     // 创建一个双向channel
      // 新建一个groutine， 模拟生产者，产生数据，写入 channel
      go producer(ch)          // channel传参， 传递的是引用。
      // 主go程，模拟消费者，从channel读数据，打印到屏幕
      consumer(ch)             // 与 producer 传递的是同一个 channel
    }
    

• 关闭channel

  • 关闭channel直接使用close()即可，但是如何确认channel是否已经关闭?可通过在读取时使用多重返回值的方式进行判断

    close(ch)
    x , ok := <- ch
    //这个用法与 map 中的按键获取 value 的过程比较类似，只需要看第二个 bool 返回值即可，如果返回值是 false 则表示 ch 已经被关闭。
    

  • 不要从接收端关闭channel，也不要关闭有多个并发发送者的channel。换句话说，如果sender(发送者)只是唯一的sender或者是channel最后一个活跃的sender，那么你应该在sender的goroutine关闭channel，从而通知receiver(s)(接收者们)已经没有值可以读了。维持这条原则将保证永远不会发生向一个已经关闭的channel发送值或者关闭一个已经关闭的channel。

• channel的读写堵塞、超时问题的解决

  • 问题：如果往channel中写数据，此时发现channel满了；如果从channel中读取数据，此时发现channel是空的，如果此时没有处理逻辑，会造成个goroutine 堵塞锁死

  • 解决：使用select实现给channel的读写设置超时机制

    func main() {
        ch := make(chan int)
        quit := make(chan bool)
        //新开一个协程
        go func() {
            for {
                select {
                      // select的每个 case 语句里必须是一个 IO 操作
                      // 如果ch成功读到数据，则进行该case处理语句
                    case num := <-ch:
                        fmt.Println("num = ", num)
                    case <-time.After(3 * time.Second):
                        fmt.Println("超时")
                        quit <- true
                }
            }
        }() //别忘了()
    
        for i := 0; i < 5; i++ {
            ch <- i
            time.Sleep(time.Second)
        }
    
        <-quit
        fmt.Println("程序结束")
    }