1. select

1.1.1. select多路复用

在某些场景下我们需要同时从多个通道接收数据。通道在接收数据时，如果没有数据可以接收将会发生阻塞。你也许会写出如下代码使用遍历的方式来实现：

  1. for{
  2.     // 尝试从ch1接收值
  3.     data, ok := <-ch1
  4.     // 尝试从ch2接收值
  5.     data, ok := <-ch2
  6.     …
  7. }

这种方式虽然可以实现从多个通道接收值的需求，但是运行性能会差很多。为了应对这种场景，Go内置了select关键字，可以同时响应多个通道的操作。

select的使用类似于switch语句，它有一系列case分支和一个默认的分支。每个case会对应一个通道的通信（接收或发送）过程。select会一直等待，直到某个case的通信操作完成时，就会执行case分支对应的语句。具体格式如下：

  1.     select {
  2.     case <-chan1:
  3.        // 如果chan1成功读到数据，则进行该case处理语句
  4.     case chan2 <- 1:
  5.        // 如果成功向chan2写入数据，则进行该case处理语句
  6.     default:
  7.        // 如果上面都没有成功，则进入default处理流程
  8.     }
  • select可以同时监听一个或多个channel，直到其中一个channel ready 
  1. package main
  3. import (
  4.    "fmt"
  5.    "time"
  6. )
  8. func test1(ch chan string) {
  9.    time.Sleep(time.Second * 5)
  10.    ch <- "test1"
  11. }
  12. func test2(ch chan string) {
  13.    time.Sleep(time.Second * 2)
  14.    ch <- "test2"
  15. }
  17. func main() {
  18.    // 2个管道
  19.    output1 := make(chan string)
  20.    output2 := make(chan string)
  21.    // 跑2个子协程，写数据
  22.    go test1(output1)
  23.    go test2(output2)
  24.    // 用select监控
  25.    select {
  26.    case s1 := <-output1:
  27.       fmt.Println("s1=", s1)
  28.    case s2 := <-output2:
  29.       fmt.Println("s2=", s2)
  30.    }
  31. }
  • 如果多个channel同时ready，则随机选择一个执行 
  1. package main
  3. import (
  4.    "fmt"
  5. )
  7. func main() {
  8.    // 创建2个管道
  9.    int_chan := make(chan int, 1)
  10.    string_chan := make(chan string, 1)
  11.    go func() {
  12.       //time.Sleep(2 * time.Second)
  13.       int_chan <- 1
  14.    }()
  15.    go func() {
  16.       string_chan <- "hello"
  17.    }()
  18.    select {
  19.    case value := <-int_chan:
  20.       fmt.Println("int:", value)
  21.    case value := <-string_chan:
  22.       fmt.Println("string:", value)
  23.    }
  24.    fmt.Println("main结束")
  25. }
  • 可以用于判断管道是否存满 
  1. package main
  3. import (
  4.    "fmt"
  5.    "time"
  6. )
  8. // 判断管道有没有存满
  9. func main() {
  10.    // 创建管道
  11.    output1 := make(chan string, 10)
  12.    // 子协程写数据
  13.    go write(output1)
  14.    // 取数据
  15.    for s := range output1 {
  16.       fmt.Println("res:", s)
  17.       time.Sleep(time.Second)
  18.    }
  19. }
  21. func write(ch chan string) {
  22.    for {
  23.       select {
  24.       // 写数据
  25.       case ch <- "hello":
  26.          fmt.Println("write hello")
  27.       default:
  28.          fmt.Println("channel full")
  29.       }
  30.       time.Sleep(time.Millisecond * 500)
  31.    }
  32. }