掌握golang select IO多路复用

select作用

Go里面提供了一个关键字select，通过select可以监听channel上的数据流动。
select的用法与switch语言非常类似，由select开始一个新的选择块，每个选择条件由case语句来描述。
与switch语句相比，select有比较多的限制，其中最大的一条限制就是每个case语句后面必须是一个Io操作 。

大致的结构如下：

select{
  case <-chan1: 
    //如果chan1成功读到数据，则进行该case处理语句
  case chan2<-1: 
    //如果成功向chan2写入数据，则进行该case处理语句
  default: 
    //如果上面都没有成功，则进入default处理流程
}

select 作用主要是配合channel实现IO多路复用

在一个select语句中，Go语言会按顺序从头至尾评估每一个发送和接收的语句。

三种状态：

如果其中的任意一语句可以继续执行（即没有被阻塞），那么就从那些可以执行的语句中任意选择一条来使用 。这不是公平的，并不是什么轮询机制

如果有可以执行的语句也有不可以执行的语句（既有阻塞队列也有不阻塞队列），那么默认走不阻塞的队列。忽略阻塞队列。

如果没有任意一条语句可以执行（即所有的通道都被阻塞），那么有两种可能的情况：

1. 如果给出了default语句，那么就会执行default语句，同时程序的执行会从select语句后的语句中恢复。如果一直都不可用那么一直执行default语句俗称忙轮询，这种用法一般不采用

2. 如果没有default语句，那么select语句将被阻塞，直到至少有一个通信可以进行下去。

使用例子：

func main(){
  ch:=make(chan int)
  quit:=make(chan int)
  go func() {
    for i := 0; i < 5; i++{
       ch<-i
        fmt.Println("写")
    }
    quit<-1
    runtime.Goexit()  //这个地方也可以不用写，因为go会自动退出这个协程
  }()

  for{
    select {
    case n:=<-ch:
      fmt.Println("读",n)
    case <-quit:
      fmt.Println("退出")
       // 坑 这个地方千万不要用break 它只会跳出 select，不会跳出for 一定要用 return才可以
      return
    }
  }
}
//输出
写
读 0
读 1
写
写
读 2
读 3
写
写
读 4
退出

坑

在使用select 时候一般我们配合for循环用，如果想跳出for,要用 return进行跳出，不要用break，因为break只会跳出select ,不会跳出for循环。 正确姿势：

for{
    select {
    case <-ch:
      fmt.Println("读")
    case <-quit:
      fmt.Println("退出")
       // 坑 这个地方千万不要用break 它只会跳出 select，不会跳出for 一定要用 return才可以
       return //终止
    }
}

还有就是如果在主协程（main）的select 内用runtime.Goexit() 进行退出 会报错： no goroutines (main called runtime.Goexit) - deadlock! ，还是要用return

用select 读取一个空的没有关闭的channel 会读取到Type的默认值，比如Type int 就是默认值0

注意事项：

1. 监听的case中，没有满足监听条件，阻塞。

2. 监听的case中，有多个满足监听条件，任选一个执行。

3. 可以使用default来处理所有case都不满足监听条件的状况。通常不用（会产生忙轮询）。

4. select自身不带有循环机制，需借助外层for来循环监听。

5. break跳出select中的一个case选项。类似于switch中的用法。

select 实现斐波那契数列：

func fibonacci(ch <-chan int, quit <-chan bool) {
  for {
    select {
    case num := <-ch:
      fmt.Print(num, " ")
    case <-quit:
      //return
      runtime.Goexit()
      //等效于returmn
    }
  }
}

func main() {
  ch := make(chan int)
  quit := make(chan bool)
  go fibonacci(ch, quit) //子go程打印fibonacc数列
  x, y := 1, 1
  for i := 0; i < 20; i++ {
    ch <- x
    x, y = y, x+y
  }
  quit <- true
}
//输出
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 

超时

有时候会出现goroutine阻塞的情况，那么我们如何避免整个程序进入阻塞的情况呢？我们可以利用select来设置超时，通过如下的方式实现：

通过time.After 进行超时退出

func main() {
  c := make(chan int)
go func(){
  for i := 0; i <20 ; i++ {
    c<-i
  }
}()

  for {
      select {
      case v := <-c:
        fmt.Println(v)
      case <-time.After(5 * time.Second): //通过time.After超时退出
        fmt.Println("超时5s退出") 
        return
      }
    }
}