让我们来复习一下switch语句，讲透接收结构在switch语句中，控制会逐个匹配case语句(可以是讲透接收结构值也可以是表达式)，一个一个的控制判断过去，直到有符合的讲透接收结构语句存在，执行匹配的控制语句内容后跳出switch。
func demo(number int){ switch{ case number >= 90: fmt.Println("优秀") default: fmt.Println("太搓了") } }而 select 用于处理通道，讲透接收结构它的控制语法与 switch 非常类似。每个 case 语句里必须是讲透接收结构一个 channel 操作。它既可以用于 channel 的控制数据接收，也可以用于 channel 的讲透接收结构数据发送。
func foo() { chanInt := make(chan int) defer close(chanInt) go func() { select { case data,控制 ok := <-chanInt: if ok { fmt.Println(data) } default: fmt.Println("全部阻塞") } }() chanInt <- 1 }输出1
这是一个简单的接收发送模型 如果 select 的多个分支都满足条件，则会随机的讲透接收结构选取其中一个满足条件的分支。 第 6 行加上 ok 是控制因为上一节讲过，如果不加会导致通道关闭时收到零值 回忆之前的讲透接收结构知识，让接收和发送在不同的goroutine里，否则会死锁这个程序存在什么问题?
假如发送太慢，亿华云计算所有case都处于阻塞状态，会直接执行default的内容。这里加一行sleep试试。
func bar() { chanInt := make(chan int) defer close(chanInt) go func() { .... }() time.Sleep(time.Second) chanInt <- 1 } 倒数第二行加了sleep 1 秒，导致select语句提前结束 猜测一下会输出全部阻塞吗? 全部阻塞 fatal error: all goroutines are asleep - deadlock! goroutine 1 [chan send]: main.bar()是会输出全部阻塞的。
因为接收执行完了，退出了goroutine，而发送才刚刚执行到，没有与其匹配的接收，故死锁。
正确的做法是把接收套在循环里面。
func baz() { chanInt := make(chan int) defer close(chanInt) go func() { for { select { ... } } }() chanInt <- 1 } 不再死锁了 假如程序不停止，会出现一个泄露的goroutine，永远的在for循环中无法跳出，此时引入下一节的内容Go 语言总是简单和灵活的，虽然没有针对提供专门的机制来处理退出，但我们可以自己组合
func main() { chanInt, done := make(chan int), make(chan struct{}) defer close(chanInt) defer close(done) go func() { for { select { case <-chanInt: case <-done: break } } }() done <- struct{}{} }没有给chanInt发送任何东西，按理说会阻塞，导致goroutine泄露
但可以使用额外的通道完成协程的退出控制
这种方式还可以做到周期性处理任务，WordPress模板下一节我们再详细讲解
case是有并发属性的，比如两次输入，分别等待 1、2 秒，再进行两次读取，会花 3 秒时间吗?
func main() { c1,c2 := make(chan string), make(chan string) close(c1) close(c2) go func() { time.Sleep(time.Second * 1) c1 <- "one" }() go func() { time.Sleep(time.Second * 2) c2 <- "two" }() start := time.Now() // 获取当前时间 for i := 0; i < 2; i++ { select { case <-c1: case <-c2: } } elapsed := time.Since(start) // 这里没有用到3秒，为什么？ fmt.Println("该函数执行完成耗时：", elapsed) }以上代码先初始化两个 channel c1 和 c2，然后开启两个 goroutine 分别往 c1 和 c2 写入数据，再通过 select 监听两个 channel，从中读取数据并输出。
运行结果如下：
$ go run channel.go received one received two 该函数执行完成耗时：2.004695535s这充分说明case是并发的，但要注意此处的并发是 case 对channel阻塞做出的特殊处理。
假如case后左边和右边跟了函数，会执行函数，我们来探索一下。
定义A、B函数，作用相同
func A() int { fmt.Println("start A") time.Sleep(1 * time.Second) fmt.Println("end A") return 1 }定义函数lee，请问该函数执行完成耗时多少呢?
func lee() { ch, done := make(chan int), make(chan struct{}) defer close(ch) go func() { select { case ch <- A(): case ch <- B(): case <-done: } }() done <- struct{}{} }答案是 2 秒
start A end A start B end B main.leespend time: 2.003504395s select 扫描是从左到右从上到下的，按这个顺序先求值，如果是IT技术网函数会先执行函数。 然后立马判断是否可以立即执行(这里是指 case 是否会因为执行而阻塞)。 所以两个函数都会进入，而且是先进入 A 再进入 B，两个函数都会执行完，所以等待时间会累计。如果都不会阻塞，此时就会使用一个伪随机的算法，去选中一个 case，只要选中了其他就被放弃了。
我们来模拟一个更真实点的例子，让程序一段时间超时退出。
定义一个结构体
type Worker struct { stream <-chan int //处理 timeout time.Duration //超时 done chan struct{} //结束信号 }定义初始化函数
func NewWorker(stream <-chan int, timeout int) *Worker { return &Worker{ stream: stream, timeout: time.Duration(timeout) * time.Second, done: make(chan struct{}), } }定义超时处理函数
func (w *Worker) afterTimeStop() { go func() { time.Sleep(w.timeout) w.done <- struct{}{} }() } 超过时间发送结束信号接收数据并处理函数
func (w *Worker) Start() { w.afterTimeStop() for { select { case data, ok := <-w.stream: if !ok { return } fmt.Println(data) case <-w.done: close(w.done) return } } } 收到结束信号关闭函数 这样的方法就可以让程序在等待 1 秒后继续执行，而不会因为 ch 读取等待而导致程序停滞。 func main() { stream := make(chan int) defer close(stream) w := NewWorker(stream, 3) w.Start() }实际 3 秒到程序运行结束。
这种方式巧妙地实现了超时处理机制，这种方法不仅简单，在实际项目开发中也是非常实用的。
本节介绍了select的用法以及包含的陷阱，我们学会了
case是并发的 case只针对通道传输阻塞做特殊处理，如果有计算将会先进行计算 扫描是从左到右从上到下的，按这个顺序先求值，如果是函数会先执行函数。如果函数运行时间长，时间会累计 在case全部阻塞时，会执行default中的内容 可使用结束信号，让select退出 延时发送结束信号可以实现超时自动退出的功能问题：为什么w.stream没有程序向他发送数据，却没有死锁呢?
本节源码位置 https://github.com/golang-minibear2333/golang/blob/master/4.concurrent/4.5-select”
本文转载自微信公众号「机智的程序员小熊」，可以通过以下二维码关注。转载本文请联系机智的程序员小熊公众号。
(责任编辑：系统运维)