在golang中，select一般是和chan一起工作的，用于同时监听多个chan的信息，其实用方法和switch差不多：

select {
case <-ch1:
    // ...
case x := <-ch2:
    // ...
case ch3 <- y:
    // ...
default:
    // ... 		
}

和switch不同的是，每个case语句都必须对应channel的读写操作，select语句会陷入阻塞，直到一个或者多个channel可以读写才能恢复

1. select的阻塞机制

1.1 select的随机选择

当多个channel都具备了读写能力的时候，也就是说多个case都可以执行的条件下，select会执行哪一个？答案是随机执行一个

我们可以写一个简单的demo，来看一下select实际的执行情况

func main() {
	c1 := make(chan int, 10)
	c2 := make(chan int, 10)
	for i := 0; i < 10; i++ {
		c1 <- i
		c2 <- i
	}
	for {
		select {
		case <-c1:
			fmt.Println("random 1")
		case <-c2:
			fmt.Println("random 2")
		default:
			//fmt.Println("default")
		}
	}
}

当两个channel c1和c2都可以读取数据时，select的执行选择是随机的

1.2 select的阻塞和控制

如果select中没有任何的channel准备好，那么当前的select所在的协程会陷入阻塞，直到有一个case满足条件

通常在实践中不想一直阻塞的话，为了避免这种情况可以加上default分支，或者加入一个超时定时器

c := make(chan int, 1)
select {
case <-c:
	fmt.Println("got it")
case <-time.After(10 * time.Second):
	fmt.Println("timeout")
}

加入定时器超时的方式在实际中很常用，可以与超时重试或者超时直接报错等方式结合

1.3 select循环等待

通常我们对于select的需求，就是想让它一直阻塞，比如我们想要监听一个chan所下达的任务

for select结构就是为此而生的，通常的做法下，select分支需要配合定时器来使用，实现超时通知或者定时任务等功能

func main() {
	c := make(chan int, 1)
	tick := time.Tick(time.Second)

	for {
		select {
		case <-c:
			fmt.Println("got it")
		case <-tick:
			fmt.Println("crontab")
		case <-time.After(800 * time.Millisecond):
			fmt.Println("timeout")
		}
	}
}

注意这里的两个定时器time.Tick和time.After

time.After在每次for中都会被重置，所以它在记录进入一次for循环的800ms时间

time.Tick是在for循环外部初始化的，所以它会按照时间累计，只要时间满1s就会执行一次定时任务

所以这两个定时器一个是为了超时重试，一个是为了执行一个间隔为1s的定时任务

1.4 select和nil channel

一个为nil的channel，读写都处于阻塞状态，如果它在case分支中，select将永远不会执行

nil channel这种特性让我们可以设计一些特殊的数据传输方法，比如现在的需求是轮流向两个channel发送数据

那么我们可以在给一个channel发送完数据之后，将其置nil

func main() {
	c1 := make(chan int)
	c2 := make(chan int)
	go func() {
		for i := 0; i < 2; i++ {
			select {
			case c1 <- 1:
				c1 = nil
			case c2 <- 2:
				c2 = nil
			}
		}
	}()

	fmt.Println(<-c1)
	fmt.Println(<-c2)
}

2. select的底层原理

select在运行时会调用核心函数selectgo

func selectgo(cas0 *scase, order0 *uint16, ncases int) (int, bool) {
	pollorder := order1[:ncases:ncases]
	lockorder := order1[ncases:][:ncases:ncases]
	for i := 1; i < ncases; i++ {
		j := fastrandn(uint32(i + 1))
		pollorder[i] = pollorder[j]
		pollorder[j] = uint16(i)
	}
}

每一个case在运行时都是一个scase结构体，存放了chan和chan中的元素类型

type scase struct {
	c    *hchan
	elem unsafe.Pointer
	kind uint16
	...
}

其中的kind代表case的类型，主要有四种类型：

• caseNil
• caseRecv
• caseSend
• caseDefault

分别对应着四种case的操作，对于每一种分支，select会执行不同的函数

在selectgo中，有两个重要的序列结构：pollorder和lockorder

pollorder是一个乱序的case序列，就是函数体中那一段for循环代码，算法类似于洗牌算法，保证了select的随机性

lockorder是按照大小对chan地址排序的算法，对所有的scase按照其chan在堆区的地址大小，使用了小顶堆算法来排序

selectgo会按照该次序对select中的case加锁，按照地址排序的顺序加锁是为了防止多个协程并发产生死锁

当所有scase中的chan加锁完毕之后，就开始第一轮循环找出是否有准备好的分支：

• 如果是caseNil，忽略
• 如果是caseRecv，判断是否有正在等待写入的协程，如果有跳转到recv分支；判断缓冲区是否有数据，如果有则跳转bufrecv分支
• 如果是caseSend，判断是否有正在等待读取的协程，如果有跳转到send分支；判断缓冲区是否有空余，如果有跳转bufsend分支
• 如果是caseDefault，记录下来，当循环结束发现没有其他case准备好时，执行default

当select完成一轮循环不能直接退出时，意味着当前协程需要进入阻塞状态等到至少一个case具备执行条件

不管是读取还是写入chan都需要创建一个新的sudog并将其放入指定通道的等待队列，之后重新进入阻塞状态

当select case中任意一个case不再阻塞时，当前协程将会被唤醒

要注意的是，最后需要将sudog结构体在其他通道的等待队列中出栈，因为当前协程已经能够正常运行，不需要再被其他通道唤醒