Go教程第二十一篇: Select

本文是《Go系列教程》的第二十一篇文章。

什么是select ？

select语句是用于从多个发送/接收的通道操作中选择一个。select语句会一直阻塞住直到有一个发送/接收操作准备就绪。如果有多个操作准备就绪的话，就会随机选择其中的一个。
此语法和switch的语法颇像，只不过每一个case语句都是一个通道操作而已。我们深入一些代码中来更好地理解。

案例

package main

import (
    "fmt"
    "time"
)

func server1(ch chan string) {
    time.Sleep(6 * time.Second)
    ch <- "from server1"
}
func server2(ch chan string) {
    time.Sleep(3 * time.Second)
    ch <- "from server2"

}
func main() {
    output1 := make(chan string)
    output2 := make(chan string)
    go server1(output1)
    go server2(output2)
    select {
    case s1 := <-output1:
        fmt.Println(s1)
    case s2 := <-output2:
        fmt.Println(s2)
    }
}

在上面的程序中，server1函数睡眠了6秒钟，之后把一个文本写入到了通道ch中。server2函数睡眠了3秒钟，之后把一个文本写入到了通道ch中。

在main函数中，我们分别调用了server1的Goroutine以及server2的Goroutine。程序之后，走到了select语句。select语句会阻塞住直到其中一个case准备就绪。在我们上面的程序中，server1的Goroutine会在6秒之后把数据写入到output1通道中，而server2则会在3秒之后把数据写入到output2通道中。因此，select语句就会阻塞3秒钟，一直等待server2的Goroutine把数据写入到output2通道中。程序在3秒之后，会输出如下：

from server2

使用select

我们在上面的程序中之所以把函数分别命名为server1和server2，主要是为了展示实际中是如何使用select的。

假定我们有一个任务关键性应用，我们应尽可能快地把结果返回给用户。针对此应用的数据库是主备型的，分布于世界各地的服务器上。若servr1和server2会和俩个服务器通信的话，每一个服务器的响应时间就取决于每个服务器的负载以及网络延迟。我们向这俩个服务器发送请求，并使用select语句等待来自相应通道上的响应信息即可。select会首先挑选出来第一个响应的，其他的响应就会被忽略掉。这种方式的话，我们可以把相同的请求发送给多个服务器，并把最快的响应返回给用户。

Default case

当没有任何case准备就绪的话，就会执行select语句中的default case。这样主要是为了防止select语句的阻塞。

package main

import (
  "fmt"
  "time"
)

func process(ch chan string) {
  time.Sleep(10500 * time.Millisecond)
  ch <- "process successful"
}

func main() {
  ch := make(chan string)
  go process(ch)
  for {
      time.Sleep(1000 * time.Millisecond)
      select {
      case v := <-ch:
          fmt.Println("received value: ", v)
          return
      default:
          fmt.Println("no value received")
      }
  }

}

在上面的程序中，process函数睡眠了10500毫秒，之后把“process successful”写入到了ch通道中。这个函数在程序的15行被并发调用。

在调用过process Goroutine之后，又在main函数的Goroutine中启动了一个无限循环。此无限循环会在每一次迭代的时候，睡眠1000毫秒，之后，执行一次select操作。
在第一个10500毫秒之后，select语句的第一个case还没有准备就绪。因为process Goroutine只有在10500毫秒之后，才会写入到ch通道中。因此，在这次迭代的时候，就会执行default case。程序将输出“no value received”10次。

在10.5秒后，process Goroutine会向ch通道中写入“process successful”。此刻，select语句的第一个case将被执行，程序将输出"received value: process successful"。
之后，程序结束，最终输出如下：

no value received
no value received
no value received
no value received
no value received
no value received
no value received
no value received
no value received
no value received
received value:  process successful

死锁和Default case

package main

func main() {
    ch := make(chan string)
    select {
    case <-ch:
    }
}

在上面的程序中，我们创建了一个通道ch。然后我们试图在select里面从此通道中读取数据。这时，此select语句将永远地阻塞住，因为没有其他任何Goroutine向该通道中写入数据。
因此，将导致死锁。运行此程序后，将报错，并提示下面这些信息。

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
    /tmp/sandbox416567824/main.go:6 +0x80

如果有default case的话，就不会发生死锁问题，因为当没有其他case可用时，就会执行default case。我们使用default case重写上面这个程序。

package main

import "fmt"

func main() {
    ch := make(chan string)
    select {
    case <-ch:
    default:
        fmt.Println("default case executed")
    }
}

上面的程序，将输出如下：

default case executed

相似地，即使select只有一个为nil的通道，default case也会被执行。

package main

import "fmt"

func main() {
    var ch chan string
    select {
    case v := <-ch:
        fmt.Println("received value", v)
    default:
        fmt.Println("default case executed")

    }
}

在上面的程序中，ch为nil。当我们试图在select语句中从ch中读取数据的时候，如果没有default case的话，select语句就会永远阻塞住，并产生死锁。
正因为我们的select语句中有了一个default case，所以程序可以正常运行，并输出如下：

default case executed

随机选择

当select语句中有多个case准备就绪的话，会随机选择其中的一个来执行。

package main

import (
    "fmt"
    "time"
)

func server1(ch chan string) {
    ch <- "from server1"
}
func server2(ch chan string) {
    ch <- "from server2"

}
func main() {
    output1 := make(chan string)
    output2 := make(chan string)
    go server1(output1)
    go server2(output2)
    time.Sleep(1 * time.Second)
    select {
    case s1 := <-output1:
        fmt.Println(s1)
    case s2 := <-output2:
        fmt.Println(s2)
    }
}

Gotcha-Empty select

package main

func main() {
    select {}
}

你认为上面的程序会输出什么？？？

我们知道，select语句会阻塞住，直到其中一个case被执行。在这种例子中，select语句没有任何case，因此，它会一直阻塞住，并产生死锁。
程序将报错输出下面信息：

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [select (no cases)]:
main.main()
    /tmp/sandbox299546399/main.go:4 +0x20

感谢您的阅读，请留下您珍贵的反馈和评论。Have a good Day!