select有点类似逻辑判断的switch 语法，但 select 不会有输入值且只用于chan操作。select 用于从多个发送或接收chan操作中进行选择，select会阻塞直到其中有chan可以操作，

  1. package main
  3. import(
  4.     "time"
  5.     "fmt"
  6. )
  8. func foo(ch chan<- string){
  9.     time.Sleep(time.Second)
  10.     ch <-"foo"
  11. }
  12. func bar(ch chan<- string){
  13.     time.Sleep(2*time.Second)
  14.     ch <-"bar"
  15. }
  17. func main() {
  18.     f :=make(chan string)
  19.     b :=make(chan string)
  20.     go foo(f)
  21.     go bar(b)
  22.     // 会出现阻塞
  23.     select {
  24.       case r :=<-f:
  25.           fmt.Println(r)
  26.     case r :=<-b:
  27.         fmt.Println(r)
  28.     }
  29. }

上面语句执行结果

  1. foo

如果有多个信道可以操作，会随机选择其中一个 case 执行,下面程序执行会随机输出

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. func foo(ch chan<- string){
  9.     ch <-"foo"
  10. }
  11. func bar(ch chan<- string){
  12.     ch <-"bar"
  13. }
  15. func main() {
  16.     f :=make(chan string)
  17.     b :=make(chan string)
  18.     go bar(b)
  19.     go foo(f)
  20.     time.Sleep(time.Second) // 为了演示随机输出 加一个延时
  21.     // 会出现阻塞
  22.     select {
  23.       case r :=<-f:
  24.           fmt.Println(r)
  25.     case r :=<-b:
  26.         fmt.Println(r)
  27.     }
  28. }

Default

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. func foo(ch chan<- string){
  8.     ch <-"foo"
  9. }
  10. func bar(ch chan<- string){
  12.     ch <-"bar"
  13. }
  15. func main() {
  16.     f :=make(chan string)
  17.     b :=make(chan string)
  18.     go bar(b)
  19.     go foo(f)
  20.     // 1执行default 2 然后会随机打印<-f 或者<-b
  21.     for {
  22.         select {
  23.         case r :=<-f:
  24.             fmt.Println(r)
  25.             return
  26.         case r :=<-b:
  27.             fmt.Println(r)
  28.             return
  29.         default:
  30.             fmt.Println("default")
  31.         }
  32.     }
  33. }

上面会首先打印default，剩下的会随机打印f或者b的chan输出

超时控制

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

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. func foo(ch chan<- string){
  9.     time.Sleep(3*time.Second)
  10.     ch <-"foo"
  11. }
  12. func bar(ch chan<- string){
  13.     time.Sleep(2*time.Second)
  14.     ch <-"bar"
  15. }
  17. func main() {
  18.     f :=make(chan string)
  19.     b :=make(chan string)
  20.     go bar(b)
  21.     go foo(f)
  22.     // 会出现超时
  23.     select {
  24.     case r :=<-f:
  25.         fmt.Println(r)
  26.     case r :=<-b:
  27.         fmt.Println(r)
  28.     case <-time.After(time.Second):
  29.         fmt.Println("time out")
  30.     }
  31. }

执行结果

  1. time out

空 select

  1. package main
  3. import "fmt"
  5. func main() {
  6.     fmt.Println("hello world")
  7.     select {
  8.     }
  9. }

空 select 语句没有 case 分支，所以便一直阻塞引起死锁。需要注意