Go select 多路复用

当一个协程需要同时等待多个通道发来数据时,我们不能直接按顺序先写 <-ch1 再写 <-ch2。因为一旦 ch1 里暂时没有数据,程序就会一直卡在第 1 行干等,哪怕此时 ch2 早就收到数据了也没法及时处理。

为了解决多个通道同时等待的问题,Go 语言提供了 select 关键字。所谓的 “多路复用”,说白了就是使用一个 select 语句同时监听多条通道,哪条通道先准备好,就优先执行哪条分支。

Go select 基本用法

在 Go 语言中,select 语句的结构和 switch 语句非常相似,内部同样由多个 case 分支和一个可选的 default 分支组成。

不过两者有着明显的区别:switch 是按从上往下的顺序判断普通条件,而 select 后面不跟任何判断表达式,它的每一个 case 分支后面都必须是针对通道的接收或发送操作。

语法:

select {
case <-通道1:
    // 分支 1 代码
case 变量 := <-通道2:
    // 分支 2 代码
case 通道3 <- 值:
    // 分支 3 代码
default:
    // 默认分支代码
}

说明:

在 select 语句中,case 支持直接接收(<-通道1)、接收并赋给变量(变量 := <-通道2)以及发送数据(通道3 <- 值)三种通道操作。整个监听和选择流程如下图所示,执行时会遵循以下 2 条基本规则:

select 多路复用监听机制

  • 未写 default 分支:select 会停在原地等待,同时监听所有 case 里的通道操作。一旦其中某一个通道率先准备就绪,程序就会立即执行对应的 case 分支,执行完后自动退出当前 select 语句。
  • 写了 default 分支:如果所有 case 的通道在当前时刻都还没有准备好,select 不会停下来等待,而是直接执行 default 分支。

示例 1:同时监听两个通道

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    // 子协程 1:200 毫秒后发送数据
    go func() {
        time.Sleep(200 * time.Millisecond)
        ch1 <- "来自通道 1 的消息"
    }()

    // 子协程 2:50 毫秒后发送数据
    go func() {
        time.Sleep(50 * time.Millisecond)
        ch2 <- "来自通道 2 的消息"
    }()

    select {
    case v1 := <-ch1:
        fmt.Printf("收到:%s\n", v1)
    case v2 := <-ch2:
        fmt.Printf("收到:%s\n", v2)
    }
}

运行结果如下。

收到:来自通道 2 的消息

分析:

在这个例子中,select 同时监听着 ch1 和 ch2 两个通道。由于子协程 1 需要休眠 200 毫秒,而子协程 2 只需要休眠 50 毫秒,因此子协程 2 会率先把数据发进 ch2。

当 ch2 收到数据的那一刻,case v2 := <-ch2: 分支立即被触发并打印出结果。这里小伙伴们要注意,单次 select 只要执行完其中一个分支就会直接退出。如果我们希望把两个通道的消息全部接收完,可以在 select 外面套上一层 for 循环,代码如下:

for i := 0; i < 2; i++ {
    select {
    case v1 := <-ch1:
        fmt.Printf("收到:%s\n", v1)
    case v2 := <-ch2:
        fmt.Printf("收到:%s\n", v2)
    }
}

注意: select 中的每一个 case 后面都必须是通道的读操作(如 <-ch)或写操作(如 ch <- v),不能写 case a > b: 这样的普通条件表达式,否则编译器会直接报错。

使用 time.After() 实现超时控制

当我们等待子协程通过通道返回结果时,如果子协程因为网络波动或接口故障迟迟没有发回数据,主协程就会在通道接收处无限期卡住。为了防止程序一直干等,我们可以使用 select 配合 time.After() 函数来实现超时控制。

与单纯暂停当前协程的 time.Sleep() 不同,time.After() 不会原地阻塞后续代码,而是立即返回一个只读通道,并在经过指定时长后自动向该通道发送时间信号。下面我们来看一个例子。

示例 2:实现通道超时控制

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan string)

    // 模拟耗时 300 毫秒的慢任务
    go func() {
        time.Sleep(300 * time.Millisecond)
        ch <- "任务处理完成"
    }()

    select {
    case res := <-ch:
        fmt.Printf("收到结果:%s\n", res)
    case <-time.After(100 * time.Millisecond):
        fmt.Println("操作超时,不再继续等待")
    }
}

运行结果如下。

操作超时,不再继续等待

分析:

case <-time.After(100 * time.Millisecond): 表示设置了一个 100 毫秒的超时限制。如果在 100 毫秒之内 ch 收到了数据,程序就会走第 1 个分支正常打印结果。

上面的子协程需要 300 毫秒才能处理完任务。因此在满 100 毫秒时,time.After() 返回的通道会率先收到信号,程序就会走第 2 个分支打印 "操作超时,不再继续等待" 并退出 select。

对于单次超时等待,直接使用 time.After() 非常省事。但如果是在高频循环中反复做超时判断,每次调用 time.After() 都会创建一个新的计时对象,此时改用可复用的定时器会更节省内存。

使用 default 实现非阻塞读写

前面我们学过,直接从暂无数据的通道执行 <-ch 接收操作,或者向缓冲区已满的通道发送数据时,当前协程都会停在原地阻塞等待。如果我们希望通道就绪时就立刻收发数据,未就绪时也不要停下来等待,而是直接去执行其他逻辑,就可以在 select 中加上 default 分支。

示例 3:非阻塞读取通道

package main

import "fmt"

func main() {
    ch := make(chan int, 1)    // 创建通道,暂不放入数据

    select {
    case v := <-ch:
        fmt.Printf("收到数据:%d\n", v)
    default:
        fmt.Println("通道中暂无数据,执行 default 分支")
    }
}

运行结果如下。

通道中暂无数据,执行 default 分支

分析:

上面代码中,通道 ch 创建后并没有放入任何数据。如果我们不加 default 分支而直接读取 ch,程序就会触发 deadlock 死锁报错。加上 default 分支后,select 发现当前没有数据可读,便会立即执行 default 分支,实现 “非阻塞读取”。

非阻塞发送也是同样的道理。当我们在 case 中向缓冲区已满的通道发送数据时,只要带有 default 分支,当前写不进去就会直接走 default 分支,不会卡住当前协程。

这里要特别提醒小伙伴们一点:千万不要把带有 default 分支的 select 直接放进死循环 for {} 里空跑。一旦所有通道都没数据,程序就会每秒执行上百万次 default 分支,瞬间把 CPU 占用率跑满 100%。

如果确实需要在循环里持续监听通道,我们直接去掉 default 分支,让 select 自然阻塞等待就可以了。

在循环中跳出 select

当把 select 放在 for 循环中持续监听通道时,很多初学的小伙伴容易踩一个坑:在 case 分支内部直接写普通的 break 语句,结果发现外层循环根本停不下来。

这是因为普通的 break 只会跳出当前的 select 语句,而不会跳出外层的 for 循环。如果我们希望在某个分支中结束外层循环,除了使用 return 直接退出整个函数之外,还可以给 for 循环加上标签,配合 break 标签名 跳出外层循环。

示例 4:带标签跳出外层循环

package main

import "fmt"

func main() {
    ch := make(chan int)
    quit := make(chan bool)

    go func() {
        ch <- 10
        ch <- 20
        quit <- true      // 发送停止监听信号
    }()

loop:
    for {
        select {
        case v := <-ch:
            fmt.Printf("收到数据:%d\n", v)
        case <-quit:
            fmt.Println("收到退出信号,跳出循环")
            break loop    // 指定标签跳出外层 for 循环
        }
    }
    fmt.Println("后续代码正常执行")
}

运行结果如下。

收到数据:10
收到数据:20
收到退出信号,跳出循环
后续代码正常执行

分析:

在这个例子中,我们在 for 循环正上方定义了一个名为 loop 的标签。当 quit 通道收到退出信号时,执行 break loop 就能一次性跳出外层的 for 循环,继续往下打印 "后续代码正常执行"。

如果这里只写普通的 break 而不带标签名,程序只会跳出当次的 select,下一轮又会回到 for 循环开头继续等待,最终引发死锁报错。要是跳出循环后不再需要执行当前函数的后续代码,我们也可以直接使用 return 退出函数,这一点小伙伴们不要搞混了。

常见问题

1. 如果在 select 执行的那一瞬间,恰好有两个 case 的通道同时准备就绪了,Go 会按从上往下的顺序先执行第 1 个吗?

不会。当 select 中有多个 case 分支在同一时刻都已经准备就绪时,Go 语言不会按代码从上往下的顺序固定选第 1 个,而是会在这些已就绪的分支中随机挑选一个来执行。

这样设计是为了保证各个通道之间的公平性,防止排在最前面的通道一直高频收发数据,导致排在后面的通道长期得不到执行机会。

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号