通过select语句可以监听channel上的数据流动
Golang的select语句类似于UNIX的select()函数的轮询机制，在UNIX中可通过调用select()函数来监控一系列的文件句柄（文件描述符，数量有限），一旦某个文件句柄发生了I/O动作select()调用就会被返回。该机制也被用于高并发的Socket服务器程序中。
select来源于网络I/O模型中的select，本质上I/O多路复用技术，只不过Golang中的select基于的并非网络而是channel。
select {
case communication clause:
statement(s)
case communication clause:
statement(s)
default:
statement(s)
}
select语句是Golang中的控制结构，类似用于通信的switch语句，也被称为channel开关。select语句会等待channel准备就绪（收发操作），以便在不同的case下执行。由select开始的一个新的选择块，每个选择条件由case语句来描述。与switch语句相比，select有较多限制，最大的限制在于每个case语句必须是一个I/O操作。
select{
case v1 := <-ch1:
fmt.Printf("[CH1] received: %v\n", v1)
case v2,ok := <-ch2:
if ok{
fmt.Printf("[CH2] received: %v\n", v2)
}else{
fmt.Printf("[CH2] closed\n")
}
case ch3 <-msg:
fmt.Printf("[CH3] sent: %v\n", msg)
default:
fmt.Printf("NO Communicating\n")
}
例如：上例select语句拥有四个case子句，前两个是channel的receive接收操作，第三个是channel的send发送操作，最后一个default默认操作。当代码执行到select语句时，case子句会按源代码的顺序进行评估，且只评估一次。评估结果会出现下面几种情况：
- 除
default外，若只有一个case评估通过则执行此case中的语句。 - 除
default外，若用多个case评估通过则随机挑选一个执行。 - 除
default外，所有的case评估都不通过，则执行default。 - 若没有
default则select代码块发生阻塞，直到有一个case通过评估，否则一直阻塞。 - 若
case中receive接收的是nil则也会发生阻塞
监听
Golang的select用来监听和channel有关的I/O操作，可监听进入channel时的数据，也可以是用channel发送值时。当I/O操作发生时会触发相应地动作，因此每个case都必须是一个I/O操作，确切的说应该是一个面向channel的I/O操作。
例如：定时器
ticker1 := time.NewTicker(time.Second * 1)
ticker2 := time.NewTicker(time.Second * 3)
for{
select{
case <-ticker1.C:
fmt.Printf("[1] TICK\n")
case <-ticker2.C:
fmt.Printf("[2] TICK\n")
}
}
在执行select语句时，运行时系统会自上而下地判断每个case中的发送或接收操作是否可以被立即执行，所谓立即执行即当前goroutine不会因此操作而被阻塞。
select语句只能用于channel的读写操作
例如：使用select来检测channel是否已满
ch := make(chan int, 1)
ch<-1
select{
case ch<-2:
fmt.Printf("send to channel\n")
default:
fmt.Printf("channel is full\n")
}
特性
- 每个
case都必须是一个channel - 所有
channel表达式都会被求值 - 所有被发送的表达式都会被求值
- 若任意某个
channel可执行就执行，其它被忽略。
例如：获取斐波拉兹数列
func fib(ch, quit chan int){
x,y := 0,1
for{
select{
case ch <- x:
x,y = y, x+y
case <-quit:
fmt.Printf("QUIT\n")
return
}
}
}
func main(){
ch := make(chan int)
quit := make(chan int)
go func(){
for i:=0; i<10; i++{
fmt.Println(<-ch)
}
quit<-0
}()
fib(ch, quit)
}
case
-
select中每个case必须是一个channel操作，要么是发送要么是接收。
select执行过程中必须命中某一case分支，若在遍历所有case后都没有命中，则会进入default分支。若没有default分支则select发生阻塞，直到某个case可以命中。若一直都没有命中，则select抛出deadlock死锁错误。
- 循环中每次
select都会对所有channel表达式求值
例如：通过time.After实现定时器，定时任务可通过done channel停止。
done := make(chan bool, 1)
close(done)
for{
select{
case <-time.After(time.Second):
fmt.Printf("Time after\n")
case <-done:
//读取零值 false
fmt.Printf("Read done\n")
}
}
- 若多个
case满足读写条件，select会随机选择一个case来执行。
select会随机执行一个可运行的case，若没有case可以运行则阻塞，直到有case可以运行。
select可用于多个channel进行读写操作时仅需一次只处理一个的情况。
ch := make(chan int, 1024)
go func(ch chan int){
for{
v := <-ch
fmt.Printf("value = %v\n", v)
}
}(ch)
ticker := time.NewTicker(time.Second * 1)
for i:=0; i<5; i++{
select{
case ch<-i:
case <-ticker.C:
fmt.Printf("%d: Ticker\n", i)
}
time.Sleep(time.Microsecond * 500)
}
close(ch)
ticker.Stop()
若ticker.C和ch同时满足读写条件时，select会随机地选择一个来执行，导致看起来一些数据丢了。
- 对于
case条件语句中若存在channel值为nil的读写操作，则该分支会被忽略。
var ch chan int
go func(ch chan int){
ch <- 100
}(ch)
select {
case <-ch:
fmt.Printf("Channel recieved\n")
}
发生错误：fatal error: all goroutines are asleep - deadlock!
default
select语句会被阻塞，直到其中一个case被执行。若select中没有任何case，它将永远阻塞，从而导致死锁。
例如：空select{}引发死锁
func main(){
select {
}
}
对于空的select语句，程序会被阻塞，准确来说是当前goroutine会被阻塞。Golang自带死锁检测机制，发现当前goroutine再也没有机会被唤醒时，则会panic。
fatal error: all goroutines are asleep - deadlock!
通过带default的select实现非阻塞读写，用于防止select发生阻塞。
select{
default:
}
多个case运行时select会随机公平地选出一个执行，其它不会执行。若存在default子句则会执行该语句。若没有default则select阻塞，直到某个通信可以运行。Go不会重新对channel或值进行求值。
当select语句永远阻塞，没有其它goroutine写入此channel时，将导致死锁。
ch := make(chan int)
select{
case <-ch:
}
fatal error: all goroutines are asleep - deadlock!
若存在默认情况default则不会发生死锁deadlock，因为在没有其它case准备就绪时将执行default默认情况。
ch := make(chan int)
select{
case <-ch:
default:
fmt.Println("default case executed")
}
例如：典型生产者消费者模式
func main(){
ch1 := make(chan int)
ch2 := make(chan int)
//生产者
go pump1(ch1)
go pump2(ch2)
//消费者
go suck(ch1, ch2)
time.Sleep(1e9)
}
-
ch1和ch2在无限循环中通过pump1()和pump2()填充整数
func pump1(ch chan int){
for i:=0; ; i++{
ch <- i * 1
}
}
func pump2(ch chan int){
for i:=0; ; i++{
ch <- i * 2
}
}
-
suck()在无限循环中轮询输入项，通过select语句获取不同信道的整数并输出。
func suck(ch1,ch2 chan int){
for{
select{
case v := <-ch1:
fmt.Printf("[CH1] receive %d\n", v)
case v := <-ch2:
fmt.Printf("[CH2] receive %d\n", v)
default:
fmt.Printf("NO Communicating\n")
}
}
}
选择select的哪一个case取决于哪个信道接收到了消息。
timeout
当case中的channel始终没有接收到数据，同时也没有提供default语句时，select语句整体会发生阻塞。有时并不希望select一直阻塞下去，此时可手动设置一个超时时间。
func expire(ch chan bool, t int){
time.Sleep(time.Second * time.Duration(t))
ch <- true
}
func main(){
timeout := make(chan bool, 1)
go expire(timeout, 2)
ch1 := make(chan string, 1)
ch2 := make(chan string, 1)
select{
case msg1 := <-ch1:
fmt.Printf("[CH1] received: %s\n", msg1)
case msg2 := <-ch2:
fmt.Printf("[CH2] received: %s\n", msg2)
case <-timeout:
fmt.Printf("[EXPIRE] exit\n")
}
}
例如：使用select实现channel的读取超时机制，不能使用default否则3秒超时未到，就会直接执行default。
timeout := make(chan bool, 1)
go func(){
time.Sleep(time.Second * 3)
timeout <- true
}()
ch := make(chan int)
select{
case <-ch:
case <-timeout:
fmt.Printf("TIMEOUT\n")
}
可使用time.After实现超时控制
ch := make(chan int)
select{
case <-ch:
fmt.Printf("read from ch\n")
case <-time.After(time.Second * time.Duration(3)):
fmt.Printf("[TIMEOUT] exit\n")
}
for
当for和select结合时，break是无法跳出for之外的，若需break出来需添加标签使用goto，或break到具体为止。
- 解决方案1：使用Golang中
break的特性在外层for上添加一个标签 - 解决方案2：使用
goto直接跳出循环到指定标记位置
- 对于
for中空的select{}也有可能会引起CPU占用过高的问题
ch := make(chan bool)
for i:=0; i一般来说，使用select监听各个case的I/O事件，每个case都是阻塞的。上例中原本希望select在获取到ch里的数据时立即退出循环，但由于在for循环中，第一次读取ch后仅仅退出了select但并未退出for，因此下次哈希继续执行select逻辑，此时将永远是执行default，直到ch里读取到数据。否则会一直在一个死循环中运行，因此即便只是放到一个goroutine中运行，也会占满所有的CPU。解决的方式直接把default拿掉，这样select会一直阻塞在ch通道的I/O上，当ch有数据时就可以随时响应通道中的信息。
select实现了一种监听模式，通常用在（无限）循环中，在某中情况下可通过break语句使循环退出。
ch := make(chan int)
//定时2s
ticker := time.NewTicker(time.Second * 2)
defer ticker.Stop()
//发送信号
go func(ch chan int){
time.Sleep(time.Second * 5)
ch <- 1
}(ch)
//监听I/O
for{
select{
case <-ticker.C:
fmt.Printf("task running...\n")
case result,ok := <-ch:{
if ok{
fmt.Printf("chan number is %v\n", result)
break
}
}
}
}
fmt.Printf("END\n")
例如：
ch := make(chan int)
quit := make(chan bool)
//写数据
go func() {
//循环写入
for i := 0; i < 5; i++ {
ch <- i
time.Sleep(time.Second)
}
//关闭channel
close(ch)
//通知主goroutine推出
quit <- true
//退出当前goroutine
runtime.Goexit()
}()
//主goroutine 读数据
for {
select {
case num := <-ch:
fmt.Printf("received number is %d\n", num)
case <-quit:
fmt.Printf("quit\n")
//break //跳出select
return //终止进程
}
fmt.Printf("==================\n")
}
多路复用
select是Golang在语言层面提供的多路I/O复用机制，它可检测多个channel是否ready（是否可读或可写）。
select是如何实现多路复用的，为什么没有在第一个channel操作时阻塞，从而导致后面的case都执行不了。