golang开发:select多路选择

select 是 Golang 中的一个控制结构，语法上类似于switch 语句，只不过select是用于 goroutine 间通信的 ，每个 case 必须是一个通信操作，要么是发送要么是接收，select 会随机执行一个可运行的 case。如果没有 case 可运行，goroutine 将阻塞，直到有 case 可运行。

select 多路选择

select写法上跟switch case的写法基本一致，只不过golang的select是通信控制语句。select的执行必须有通信的发送或者接受，如果没有就一直阻塞。

  1. ch := make(chan bool, 0)
  2.     ch1 := make(chan bool, 0)
  3.     select {
  4.         case ret := <-ch:
  5.             fmt.Println(ret)
  6.         case ret := <-ch1:
  7.             fmt.Println(ret)
  8.     }

如果ch和ch1都没有通信数据发送，select就一直阻塞，直到ch或者ch1有数据发送，select就执行相应的case来接受数据。

select 实现超时控制

我们可以利用select机制实现一种简单的超时控制。
先看下程序完整执行的代码

  1. func service(ch chan bool) {
  2.     time.Sleep(time.Second*3)
  3.     ch<-true
  4. }
  5. func main() {
  6.     ch := make(chan bool, 0)
  7.     go service(ch)
  8.     select {
  9.         case ret := <-ch:
  10.             fmt.Println(ret)
  11.         case <-time.After(time.Second*5):
  12.             fmt.Println("timeout")
  13.     }
  14. }
  15. ___go_build_main_go #gosetup
  16. true

可以看到使用time.After超时定义了5S，service程序执行3S，所以肯定没有超时，跟预想的一致。
我们再看看超时的执行，我们将service程序执行时间该为6S。超时控制继续是5S，再看下执行效果

  1. func service(ch chan bool) {
  2.     time.Sleep(time.Second*6)
  3.     ch<-true
  4. }
  5. func main() {
  6.     ch := make(chan bool, 0)
  7.     go service(ch)
  8.     select {
  9.         case ret := <-ch:
  10.             fmt.Println(ret)
  11.         case <-time.After(time.Second*5):
  12.             fmt.Println("timeout")
  13.     }
  14. }
  15. ___go_build_main_go #gosetup
  16. timeout

执行到了超时的case，跟预想的其实是一致的。

select 判断channel是否关闭

先看下接受数据的语法

  1. val,ok <- ch
  2. ok true 正常接收数据
  3. ok false 通道关闭

可以看到接受数据其实有两个参数，第二个bool值会反应channel是否关闭，是否可以正常接受数据。
看下测试代码
我们写了一个数据发送者，两个数据接收者，当发送者关闭channel的时候，两个接收者的 goroutine 可以通过以上的语法判断channel是否关闭，决定自己的 goroutine 是否结束。

  1. func sender(ch chan int, wg *sync.WaitGroup) {
  2.     for i:=0;i<10;i++ {
  3.         ch<-i
  4.     }
  5.     close(ch)
  6.     wg.Done()
  7. }
  8. func receiver(ch chan int, wg *sync.WaitGroup) {
  9.     for {
  10.         if val,ok := <-ch;ok {
  11.             fmt.Println(fmt.Sprintf("%d,%s",val, "revevier"))
  12.         } else {
  13.             fmt.Println("quit recevier")
  14.             break;
  15.         }
  16.     }
  17.     wg.Done()
  18. }
  19. func receiver2(ch chan int, wg *sync.WaitGroup) {
  20.     for {
  21.         if val,ok := <-ch;ok {
  22.             fmt.Println(fmt.Sprintf("%d,%s",val, "revevier2"))
  23.         } else {
  24.             fmt.Println("quit recevier2")
  25.             break;
  26.         }
  27.     }
  28.     wg.Done()
  29. }
  30. func main() {
  31.     ch := make(chan int, 0)
  32.     wg := &sync.WaitGroup{}
  33.     wg.Add(1)
  34.     go sender(ch, wg)
  35.     wg.Add(1)
  36.     go receiver(ch, wg)
  37.     wg.Add(1)
  38.     go receiver2(ch, wg)
  39.     wg.Wait()
  40. }

执行结果

  1. 0,revevier2
  2. 2,revevier2
  3. 3,revevier2
  4. 4,revevier2
  5. 5,revevier2
  6. 6,revevier2
  7. 7,revevier2
  8. 1,revevier
  9. 9,revevier
  10. quit recevier
  11. 8,revevier2
  12. quit recevier2

可以看到一个数据发送者，两个数据接收者，当channel关闭的时候，两个数据接收者都收到了channel关闭的通知。
需要注意的是，给一个已经关闭的channel发送数据，程序会panic，从一个已经关闭的channel接收数据，会接收到没有参考意义的channel类型的0值数据，Int是0，string是空…

select 退出计时器等程序

开发中经常会经常会使用轮训计时器，但是当程序退出时，轮训计时器无法关闭的问题。其实select是可以解决这个问题的。
如果我们有一个轮训任务，需要一个timer，每隔3S执行逻辑，过完10S之后关闭这个timer。
看下代码

func TimeTick(wg *sync.WaitGroup,q chan bool) {
    defer wg.Done()
    t := time.NewTicker(time.Second*3)
    defer t.Stop()
    for {
        select {
        case <-q:
            fmt.Println("quit")
            return
        case <-t.C:
            fmt.Println("seconds timer")
        }
    }
}
func main() {
    q := make(chan bool)
    wg := new(sync.WaitGroup)
    wg.Add(1)
    go TimeTick(wg,q)
    time.Sleep(time.Second*10)
    close(q)
    wg.Wait()
}

执行结果

seconds timer
seconds timer
seconds timer
quit

很优雅的通过关闭channel退出了轮训计时器 goroutine，