迹忆客 专注技术分享

在 Go select 教程中我们简单介绍了select的知识点。这里我们对select进行深入详细的介绍。

什么是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 协程 server1 和 server2。

控制器到达 select 语句。 select 语句会阻塞，直到它的一种情况准备就绪。 在我们上面的程序中，server1 Goroutine 在 6 秒后写入 output1 通道，而 server2 在 3 秒后写入 output2 通道。 所以 select 语句会阻塞 3 秒，并等待 server2 Goroutine 写入 output2 通道。 3 秒后，程序打印如下内容

然后程序终止。

select 的实际应用

之所以将上述程序中的函数命名为 server1 和 server2，是为了说明select的实际使用。

假设我们有一个关键任务应用程序，我们需要尽快将输出返回给用户。 此应用程序的数据库被复制并存储在世界各地的不同服务器中。 假设函数 server1 和 server2 实际上正在与 2 个这样的服务器通信。 每个服务器的响应时间取决于每个服务器的负载和网络延迟。 我们将请求发送到两个服务器，然后使用 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 <- "处理成功！"
}

func main() {  
    ch := make(chan string)
    go process(ch)
    for {
        time.Sleep(1000 * time.Millisecond)
        select {
        case v := <-ch:
            fmt.Println("接收的值: ", v)
            return
        default:
            fmt.Println("没有接收到值")
        }
    }

}

运行示例

在上面的程序中，process 函数休眠 10500 毫秒（10.5 秒），然后将字符串“处理成功”写入 ch 通道。该函数并发调用。

并发调用 process Goroutine 后，在主 Goroutine 中启动无限循环。无限循环在每次迭代开始期间休眠 1000 毫秒（1 秒），然后执行 select 操作。在前 10500 毫秒内，select 语句的第一个 case，即 case v := <-ch: 不会准备好，因为 process Goroutine 只会在 10500 毫秒后写入 ch 通道。因此在此期间将执行默认情况，并且程序将打印 10 次 “没有接收到值”。

10.5 秒后，process Goroutine 将“处理成功！”写入ch。 现在将执行 select 语句的第一个 case，程序将打印“接收的值: 处理成功！”，然后将终止。该程序将输出如下内容

死锁和 default case

package main

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

<a href='https://tools.jiyik.com/run_code/go_deadlock_default_case' class='run-code' target='_blank'>运行示例</a>

在上面的程序中，我们创建了一个通道 ch。 我们尝试在 select 中从该通道接收数据。 select 语句将永远阻塞，因为没有其他 Goroutine 在写入此通道，因此将导致死锁。 该程序将在运行时产生 panic 并显示以下内容

如果存在 default 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

随机选择 case

当 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)
    }
}

运行示例

在上面的程序中，分别调用go 协程 server1 和 server2 。 然后主程序休眠 1 秒。 当控制器到达 select 语句时，server1 将 “from server1” 写入到 output1 通道，而 server2 将 “from server2” 写入到 output2 通道，因此 select 语句的两种情况都已准备好执行。 如果多次运行此程序，则输出将在 server1 或 server2 之间有所不同，具体取决于随机选择的情况。

请在本地机器上运行此程序，从而可以保证其随机性。 如果点击上面的运行示例，它执行的结果相同。

空 select

package main

func main() {  
    select {}
}

运行示例

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

我们知道 select 语句会阻塞，直到它的一种情况被执行。 在这种情况下，select 语句没有任何 case，因此它将永远阻塞，从而导致死锁。 该程序将进入panic