Golang select 用法与实现原理

恋喵大鲤鱼

已于 2023-12-22 19:02:14 修改

阅读量2.4k

点赞数 1

分类专栏： Golang 文章标签： golang select

于 2023-02-22 15:36:41 首次发布

本文链接：https://blog.csdn.net/K346K346/article/details/126757892

版权

Golang 专栏收录该内容

61 篇文章

订阅专栏

文章目录

1.简介
2.基本语法
3.实现原理
4.小结
参考文献

1.简介

Golang 中的 select 语句是用于多路复用的一种语言结构，用于同时等待多个通道上的数据，并执行相应的代码块。

也就是说 select 是用来监听和 channel 有关的 IO 操作，它与 select，poll，epoll 相似，当 IO 操作发生时，触发相应的动作，实现 IO 多路复用。

特性如下：

case 必须是一个通信操作。
select 语句中除 default 外，各 case 执行顺序是随机的。
select 语句中如果没有 default 语句，则会阻塞等待任意一个 case。
select 语句中除 default 外，每个 case 只能操作一个 channel，要么读要么写。
当 select 中的多个 case 同时被触发时，会随机执行其中的一个。

2.基本语法

select {
    case <-channel1:
        // 处理 channel1 上的数据
    case data := <-channel2:
        // 处理 channel2 上的数据
    case channel3 <- data:
        // 将数据写入 channel3
    default:
        // 没有任何 channel 可用
}

select 语句会等待多个通道中的数据，一旦某个通道上有数据可读或可写，就会执行相应的 case 子句。

如果多个 case 子句同时满足条件，则随机选择其中一个执行。

如果没有任何 case 子句满足条件，则执行 default 子句。

如果没有 default 子句，则 select 会一直阻塞，直到有 channel 可用。

注意，select 读操作要判断是否成功读取，因为关闭的 channel 也可以读取，此时 ok 为 false。

case elem, ok := <-chan1:

3.实现原理

3.1 概述

select 语句是基于 Golang 运行时的调度器实现的 IO 多路复用。可以同时监控多个通道的状态，并在某个通道就绪时将其对应的 case 子句加入调度队列中等待执行。当某个 case 子句执行完毕后，select 语句就会结束，并返回对应的结果。

Golang 运行时调度器是一种基于 goroutine 的协作式调度机制，它能够在多个 goroutine 之间进行高效的上下文切换，从而实现并发执行。在调度器的实现中，每个 goroutine 会绑定到一个系统线程上，而系统线程则会在操作系统层面上执行调度，以实现多线程并发。调度器会监控每个 goroutine 的状态，并在 goroutine 处于阻塞状态时，将其从系统线程上解绑，然后将系统线程用于执行其他 goroutine，从而避免了阻塞操作对整个程序的影响。

在 Golang 中，使用 select 语句可以轻松地实现 IO 多路复用。当 select 语句被执行时，运行时调度器会将所有 case 子句中的通道加入到一个调度器队列中，并监控这些通道的状态。当有数据可读或可写时，调度器就会选择其中一个 case 子句，并将其对应的代码块加入到调度队列中等待执行。

3.2 数据结构

Golang 实现 select 时，并没有一个数据结构表示 select，但是有一个数据结构表示 case 语句（含 defaut，default 实际上是一种特殊的 case）。

select 执行过程可以类比成一个函数，函数输入case 数组，输出选中的 case，然后程序流程转到选中的 case 块

我们先看一下 case 的数据结构（go 1.19 runtime/select.go）。

// Select case descriptor.
// Known to compiler.
// Changes here must also be made in src/cmd/compile/internal/walk/select.go's scasetype.
type scase struct {
	c    *hchan         // chan
	elem unsafe.Pointer // data element
}

因为 case 中都与 Channel 的发送和接收有关，所以 runtime.scase 结构体包含一个 runtime.hchan 类型的字段存储 case 中使用的 Channel。

elem 表示缓冲区地址，表示从 Channel 读出的数据存放地址或将要写入 Channel 的数据存放地址。

3.3 实现原理

编译优化

首先在编译期间，Go 语言会对 select 语句进行优化，它会根据 select 中 case 的不同选择不同的优化路径：

不存在任何 case。

空的 select 语句会被转换成调用 runtime.block() 函数，直接挂起当前 Goroutine。

只存在一个 case。

如果 select 语句中只包含一个 case，编译器会将其转换成普通的通信操作，而不是一个真正的 select 。

多个 case 其中有一个是 default。

如果 select 语句中只包含多个 case 并且其中一个是 default，那么会使用 runtime.selectnbrecv() 和 runtime.selectnbsend() 函数非阻塞地执行收发操作。

多个 case 无 default。

编译器会使用如下的流程处理 select 语句：

将所有的 case 转换成包含 channel 以及类型等信息的 runtime.scase 结构体。
调用运行时函数 runtime.selectgo() 从多个准备就绪的 channel 中选择一个可执行的 runtime.scase 结构体。
生成一组 if 语句，在语句中判断自己是不是被选中的 case，然后执行 case 对应的代码块。

一个包含三个 case 的正常 select 语句其实会被展开成如下所示的逻辑：

selv := [3]scase{}
order := [6]uint16
for i, cas := range cases {
    c := scase{}
    c.kind = ...
    c.elem = ...
    c.c = ...
}
chosen, revcOK := selectgo(selv, order, 3)
if chosen == 0 {
    ...
    break
}
if chosen == 1 {
    ...
    break
}
if chosen == 2 {
    ...
    break
}

运行时

在编译器已经对 select 语句进行优化之后，Go 语言会在运行时执行编译期间展开的 runtime.selectgo() 函数，该函数的主要作用是用于选择就绪的 case。

源码 runtime.selectgo()（src/runtime/select.go）函数实现了 select 语句。

// selectgo implements the select statement.
//
// cas0 points to an array of type [ncases]scase, and order0 points to
// an array of type [2*ncases]uint16 where ncases must be <= 65536.
// Both reside on the goroutine's stack (regardless of any escaping in
// selectgo).
//
// For race detector builds, pc0 points to an array of type
// [ncases]uintptr (also on the stack); for other builds, it's set to
// nil.
//
// selectgo returns the index of the chosen scase, which matches the
// ordinal position of its respective select{recv,send,default} call.
// Also, if the chosen scase was a receive operation, it reports whether
// a value was received.
func selectgo(cas0 *scase, order0 *uint16, pc0 *uintptr, nsends, nrecvs int, block bool) (int, bool)