select 与 switch
让我们来复习一下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泄露
但可以使用额外的通道完成协程的退出控制
这种方式还可以做到周期性处理任务,下一节我们再详细讲解
case 的并发性
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并发的原理
假如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 扫描是从左到右从上到下的,按这个顺序先求值,如果是函数会先执行函数。
- 然后立马判断是否可以立即执行(这里是指 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”
本文转载自微信公众号「机智的程序员小熊」,可以通过以下二维码关注。转载本文请联系机智的程序员小熊公众号。