〇、select 简介
select 语句类似于 switch 语句，但是 select 会随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。
select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。默认的子句 default 应该总是可运行的。
操作系统中实现 IO 多路复用的命令 select、poll、epoll，主要通过起一个线程，来监听并处理多个文件描述符代表的 TCP 链接，用来提高处理网络读写请求的效率。而 Go 语言的 select 命令，是用来起一个 goroutine 协程监听多个 Channel（代表多个 goroutine）的读写事件，提高从多个 Channel 获取信息的效率。二者具体目标和实现不同，但本质思想都是相同的。
一、select 测试
1.1 当没有 case 可运行时
由于 Go 自带死锁检测机制，当发现当前协程（goroutine ）没有机会被唤醒时，则会发生 panic：
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [select]:
main.main()
E:/test/main.go:8 +0x87情况一：select 内容为空：
package main
func main() {
select {}
}此时 goroutine 默认永远阻塞。
情况二：select 内容不为空，但没有可运行的 case：
package main
import "fmt"
func main() {
ch1 := make(chan int, 1)
ch2 := make(chan int)
select {
case <-ch1:
// 从有缓冲chan中读取数据，由于缓冲区没有数据且没有发送者，该分支会阻塞
fmt.Println("Received from ch")
case i := <-ch2:
// 从无缓冲chan中读取数据，由于没有发送者，该分支会阻塞
fmt.Printf("i is: %d", i)
}
}1.2 select 的默认运行项 default
当没有其他可运行的 case 时，执行 default 分支：
package main
import "fmt"
func main() {
ch1 := make(chan int, 1)
select {
case <-ch1:
// 从有缓冲 chan 中读取数据，由于缓冲区没有数据且没有发送者，该分支会阻塞
fmt.Println("Received from ch")
default:
fmt.Println("this is default")
}
}输出：
1.3 同时存在多个可执行的分支时，随机执行其中一个
如下三个分支均满足执行条件：
package main
import "fmt"
func main() {
ch := make(chan int, 1)
ch <- 10
select {
case val := <-ch:
fmt.Println("Received from ch1, val =", val)
case val := <-ch:
fmt.Println("Received from ch2, val =", val)
case val := <-ch:
fmt.Println("Received from ch3, val =", val)
default:
fmt.Println("Run in default")
}
}如下图连续运行了四次，可以看出执行的 case 并不固定：
二、几个典型用法
2.1 超时判断
如下代码，使用全局 resChan 来接受 response，如果时间超过 3s，resChan 中还没有数据返回，则第二条 case 将执行。
package main
import (
"fmt"
"time"
)
func main() {
test()
}
var resChan = make(chan int)
func test() {
select {
case data := <-resChan:
fmt.Println("data:", data)
case <-time.After(time.Second * 3): // 配置超时时间 3 秒钟
fmt.Println("request time out")
}
}结果输出：
2.2 根据信号退出运行
如下代码，在协程中操作关闭通道，主线程监控到后退出：
package main
import (
"fmt"
"time"
)
var shouldQuit = make(chan struct{})
func main() {
fmt.Println("main...")
go quit() // 另开一个协程 goroutine
select {
case <-shouldQuit:
fmt.Println("shouldQuit...")
return
case <-time.After(time.Second * 2): // 超时时调用
fmt.Println("request time out")
}
}
func quit() {
time.Sleep(1 * time.Second)
close(shouldQuit) // close 函数用来关闭通道，表示没有更多的值将被发送到该通道
}当协程中 time.Sleep() 配置小于 2s，就会执行 select 中的第一个 case，超过 2s 时，就会执行第二个 case 提示超时。
2.3 判断 channel 是否阻塞
判断是否阻塞，实际上就是加上 default，当其他 case 都获取不到值时，通过 default 的操作，来知道 channel 是否阻塞：
package main
import (
"fmt"
"time"
)
func main() {
ch := make(chan int, 1)
// // 向 channel 发送一个值
// ch <- 1
// fmt.Println("向 channel 发送了一个值：1")
// 使用 select 语句判断 channel 是否阻塞
select {
case v := <-ch:
fmt.Println("从 channel 中读取到值：", v)
default:
fmt.Println("channel 阻塞")
}
fmt.Println("模拟阻塞等待。。")
// 模拟阻塞等待
time.Sleep(2 * time.Second)
fmt.Println("模拟阻塞等待。。2s")
}
三、select 并发编程
select 同时监控多个 channel，直到其中一个 channel 准备好：
package main
import (
"fmt"
"time"
)
func test1(ch chan string) {
time.Sleep(time.Second * 5)
ch <- "test1"
}
func test2(ch chan string) {
time.Sleep(time.Second * 2)
ch <- "test2"
}
func main() {
// 2个管道
output1 := make(chan string)
output2 := make(chan string)
// 跑2个子协程，写数据
go test1(output1)
go test2(output2)
// 用select监控
select {
case s1 := <-output1:
fmt.Println("s1 =", s1)
case s2 := <-output2:
fmt.Println("s2 =", s2)
}
}如下代码，判断管道是否存满：（设置写入比读取快）
package main
import (
"fmt"
"time"
)
// 判断管道有没有存满
func main() {
// 创建管道
output1 := make(chan string, 2)
// 子协程写数据
go write(output1)
// 取数据
for s := range output1 {
fmt.Println("res:", s)
time.Sleep(time.Second) // 间隔 1s 读取
}
}
func write(ch chan string) {
for {
select {
// 尝试写数据
case ch <- "hello":
fmt.Println("write hello")
default:
fmt.Println("channel full")
}
time.Sleep(time.Millisecond * 500) // 间隔 0.5s 写入
}
}
参考： http://www.topgoer.com/%E5%B9%B6%E5%8F%91%E7%BC%96%E7%A8%8B/select.htm
若想了解 select 底层原理可以参考：https://cloud.tencent.com/developer/article/2205909
标签：语句,case,fmt,chan,func,GO,main,select From： https://www.cnblogs.com/hnzhengfy/p/Go_select.html