什么是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秒，然后将文本"from server1"写入通道ch。server2 函数休眠3秒钟，然后"from server2"写入通道ch。main 函数调用 go Goroutines server1 和 server2。

程序运行到达 select 语句，select 语句将阻塞，直到其中一个case准备就绪。在上面的程序中，server1 Goroutine在6秒后写入output1 channel，而server2在3秒后写入output2 channel。因此，select 语句将阻塞3秒，并等待 server2 Goroutine 写入output2 channle。3秒后，程序打印：

from server2 

之后程序中断。

select的实际用法

将上述程序中的函数命名为 server1 和 server2 的原因是为了说明 select 的实际用法。

假设我们有一个任务关键型应用程序，我们需要尽快将输出返回给用户。此应用程序的数据库被复制并存储在世界各地的不同服务器中。假设函数server1和server2实际上正在与2个这样的服务器通信，每个服务器的响应时间取决于每个服务器上的负载和网络延迟，我们将请求发送到两个服务器，然后使用 select 语句在相应的channel上等待响应。首先响应的服务器由select语句选择，另外的响应被忽略。这样，我们可以将相同的请求发送到多个服务器，并将最快的响应返回给用户。

select语句中的default 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毫秒（10.5 秒），然后将"process successful"写入 ch 通道。此函数在程序的main函数中被调用。同时调用Goroutine 后，在主 Goroutine 中启动一个无限的 for 循环。无限循环在每次迭代开始时休眠1000毫秒（1秒），然后执行select语句，在前10500毫秒内，select 语句的第一种情况，即 case v := <-ch，将不会准备就绪，因为进程 Goroutine 只会在10500毫秒后写入 ch 通道。因此，default case将在此期间执行，程序将打印10次"no value received"。在10.5 秒后，Goroutine 将"process successful"写入ch，将执行select语句的第一个情况，程序将打印"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 channel，尝试从select中的ch channel读取。select 语句将永远阻塞，因为没有其他 Goroutine 写入此通道，因此将导致死锁。该程序将在运行时死机并显示以下消息：

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:  
main.main()  
    /tmp/sandbox627739431/prog.go:6 +0x4d

如果存在default case，则不会发生此死锁，因为default case将在没有其他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 channel，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 channel是nil，但是select语句中尝试从ch channel中读取值，如果select中没有default case，程序将一直阻塞并且导致死锁。因此当有nil channel时，在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)
    }
}

上面的程序中，server1和server2 goroutines分别被调用，当主程序sleep 1秒后，output1和output2将分别写入字符，因此select语句中的两个case都准备就绪，这时将随机选择一个case执行。你可以本地执行验证它的随机性。

陷阱--空select

package main

func main() {  
    select {}
}

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

我们都知道select语句会一直阻塞直到它的case执行。在这个例子中，select语句中没有任何case，因为它会一直阻塞，直至产生死锁。这个程序将会panic并由如下的输出：

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [select (no cases)]:  
main.main()  
    /tmp/sandbox246983342/prog.go:4 +0x25