select语句选择一组可能的send操作和receive操作去处理。它类似switch,但是只是用来处理通讯(communication)操作。
它的case可以是send语句,也可以是receive语句,亦或者default
receive语句可以将值赋值给一个或者两个变量。它必须是一个receive操作。
最多允许有一个default case,它可以放在case列表的任何位置,尽管我们大部分会将它放在最后。

  1. package main
  2. import (
  3. "fmt"
  4. "strconv"
  5. "time"
  6. )
  7. func collector(c chan string, n int){
  8. for {
  9. time.Sleep(time.Second*1)
  10. c <- "imooc"+strconv.Itoa(n)
  11. //fmt.Println(fmt.Sprintf("%d 获取到了数据"))
  12. }
  13. }
  14. func main(){
  15. msg1 := make(chan string)
  16. msg2 := make(chan string)
  17. go collector(msg1, 1)
  18. go collector(msg2, 2)
  19. //for{
  20. // data, ok := <-msg1
  21. // if ok {
  22. // fmt.Println(data)
  23. // }
  24. // data, ok = <-msg2
  25. // if ok {
  26. // fmt.Println(data)
  27. // }
  28. //}
  29. for{
  30. select {
  31. case data1 := <- msg1:
  32. fmt.Println(data1)
  33. case data2 := <- msg2:
  34. fmt.Println(data2)
  35. }
  36. }
  37. }

如果有同时多个case去处理,比如同时有多个channel可以接收数据,那么Go会伪随机的选择一个case处理(pseudo-random)。如果没有case需要处理,则会选择default去处理,如果default case存在的情况下。如果没有default case,则select语句会阻塞,直到某个case需要处理。
需要注意的是,nil channel上的操作会一直被阻塞,如果没有default case,只有nil channel的select会一直被阻塞。
select语句和switch语句一样,它不是循环,它只会选择一个case来处理,如果想一直处理channel,你可以在外面加一个无限的for循环:

  1. for {
  2. select {
  3. case c <- x:
  4. x, y = y, x+y
  5. case <-quit:
  6. fmt.Println("quit")
  7. return
  8. }
  9. }

11.5.1 timeout

select有很重要的一个应用就是超时处理。 因为上面我们提到,如果没有case需要处理,select语句就会一直阻塞着。这时候我们可能就需要一个超时操作,用来处理超时的情况。
下面这个例子我们会在2秒后往channel c1中发送一个数据,但是select设置为1秒超时,因此我们会打印出timeout 1,而不是result 1

  1. import "time"
  2. import "fmt"
  3. func main() {
  4. c1 := make(chan string, 1)
  5. go func() {
  6. time.Sleep(time.Second * 2)
  7. c1 <- "result 1"
  8. }()
  9. select {
  10. case res := <-c1:
  11. fmt.Println(res)
  12. case <-time.After(time.Second * 1):
  13. fmt.Println("timeout 1")
  14. }
  15. }

其实它利用的是time.After方法,它返回一个类型为<-chan Time的单向的channel,在指定的时间发送一个当前时间给返回的channel中。

11.5.2 Timer和Ticker

我们看一下关于时间的两个Channel。
timer是一个定时器,代表未来的一个单一事件,你可以告诉timer你要等待多长时间,它提供一个Channel,在将来的那个时间那个Channel提供了一个时间值。下面的例子中第二行会阻塞2秒钟左右的时间,直到时间到了才会继续执行。

  1. timer1 := time.NewTimer(time.Second * 2)
  2. <-timer1.C
  3. fmt.Println("Timer 1 expired")

当然如果你只是想单纯的等待的话,可以使用time.Sleep来实现。
你还可以使用timer.Stop来停止计时器。

  1. timer2 := time.NewTimer(time.Second)
  2. go func() {
  3. <-timer2.C
  4. fmt.Println("Timer 2 expired")
  5. }()
  6. stop2 := timer2.Stop()
  7. if stop2 {
  8. fmt.Println("Timer 2 stopped")
  9. }

ticker是一个定时触发的计时器,它会以一个间隔(interval)往Channel发送一个事件(当前时间),而Channel的接收者可以以固定的时间间隔从Channel中读取事件。下面的例子中ticker每500毫秒触发一次,你可以观察输出的时间。

  1. ticker := time.NewTicker(time.Millisecond * 500)
  2. go func() {
  3. for t := range ticker.C {
  4. fmt.Println("Tick at", t)
  5. }
  6. }()

类似timer, ticker也可以通过Stop方法来停止。一旦它停止,接收者不再会从channel中接收数据了。