在go语言中，当select语句的default分支在一个紧密的忙循环中执行纯计算任务时，可能会导致其他协程（如time.Ticker管理的协程）因无法获得调度而“饥饿”，从而无法正常工作。这是由于Go的协程调度器是协作式的，需要明确的调度点。本文将深入探讨这一现象的原理，并提供通过引入I/O操作、使用runtime.Gosched()或time.Sleep()等方法来解决协程饥饿问题的实践指南。

理解Go协程调度与select的default分支

go语言以其轻量级协程（goroutine）和强大的并发原语而闻名。select语句是处理多个通道操作的核心工具，它允许程序等待多个通信操作中的任意一个完成。当所有case分支都无法立即执行时，select语句会执行其default分支（如果存在）。

然而，当select语句被放置在一个紧密的无限循环中，并且其default分支中只包含纯粹的计算逻辑，没有任何能触发Go调度器进行协程切换的操作时，就可能出现协程“饥饿”的问题。

问题示例：time.Ticker的“失灵”

考虑以下代码片段，它尝试使用time.NewTicker来周期性地打印消息：

package main  import (     "fmt"     "time"     // "runtime" // 稍后会用到 )  func main() {     rt := time.NewTicker(time.Second / 60) // 每秒60次     for {         select {         case <-rt.C:             fmt.Println("time tick")         default:             // 在这里执行一些纯计算任务，或什么都不做             // fmt.Println("default") // 加上这行会改变行为         }         // time.Sleep(1 * time.Millisecond) // 加上这行也会改变行为     } }

当你运行上述代码（不包含注释掉的fmt.Println或time.Sleep）时，你会发现”time tick”这条消息几乎永远不会被打印出来。time.Ticker似乎“停止”了工作。但如果我们在default分支中添加一行fmt.Println(“default”)，或者在循环末尾添加time.Sleep(1 * time.Millisecond)，程序就会按照预期工作，周期性地打印”time tick”。

立即学习“go语言免费学习笔记（深入）”；

协程饥饿的根本原因

这种“奇怪”行为的根源在于Go语言的协作式调度器。Go调度器在以下几种情况下会考虑切换协程：

1. I/O操作： 当协程执行阻塞的I/O操作（如网络请求、文件读写、打印到控制台等）时。
2. 通道操作： 当协程尝试在阻塞的通道上发送或接收数据时。
3. 系统调用： 当协程执行阻塞的系统调用时。
4. 明确的调度点： 通过runtime.Gosched()函数显式地让出CPU。
5. 垃圾回收： 某些垃圾回收阶段可能触发调度。
6. time.Sleep()： 协程进入睡眠状态时。

在上述问题示例中，main协程在一个紧密的循环中不断地命中select的default分支。如果default分支中没有任何I/O操作、通道操作、系统调用或runtime.Gosched()，那么main协程将一直占用CPU，形成一个忙循环。

time.NewTicker会启动一个独立的协程来管理计时器，并在每个时间间隔向rt.C通道发送一个值。然而，如果main协程持续忙碌，Go调度器就没有机会将CPU时间分配给Ticker协程，导致Ticker协程无法运行，也就无法向rt.C发送数据。因此，select的case <-rt.C分支永远无法被触发。

解决方案

解决协程饥饿问题的核心在于，在忙循环中为Go调度器提供一个切换协程的机会。

Sitekick

一个AI登陆页面自动构建器

73

查看详情

1. 引入I/O操作

最简单的解决方案之一是在default分支中执行一个I/O操作，例如fmt.Println()。fmt.Println()会进行系统调用以将数据写入标准输出，这个过程会触发Go调度器进行协程切换。

package main  import (     "fmt"     "time" )  func main() {     rt := time.NewTicker(time.Second / 60)     for {         select {         case <-rt.C:             fmt.Println("time tick")         default:             // 引入I/O操作，触发调度             fmt.Println("default actions (with implicit yield)")         }     } }

通过这种方式，main协程在每次循环迭代中都会“暂停”一下，给Ticker协程运行的机会。

2. 显式让出CPU：runtime.Gosched()

runtime.Gosched()函数允许当前协程主动让出CPU，以便调度器可以运行其他协程。这是一个明确告诉调度器“我现在可以暂停，让别人运行”的方式。

package main  import (     "fmt"     "runtime" // 导入runtime包     "time" )  func main() {     rt := time.NewTicker(time.Second / 60)     for {         select {         case <-rt.C:             fmt.Println("time tick")         default:             // 显式让出CPU             runtime.Gosched()         }     } }

使用runtime.Gosched()是解决忙循环中协程饥饿问题的推荐方法，因为它清晰地表达了意图，并且不会引入不必要的I/O或延迟。

3. 引入短暂睡眠：time.Sleep()

time.Sleep()函数会让当前协程暂停执行指定的时间。当协程进入睡眠状态时，调度器会将其从运行队列中移除，并允许其他协程运行。

package main  import (     "fmt"     "time" )  func main() {     rt := time.NewTicker(time.Second / 60)     for {         select {         case <-rt.C:             fmt.Println("time tick")         default:             // 引入短暂睡眠，让出CPU             time.Sleep(1 * time.Millisecond) // 即使是很短的时间也有效         }     } }

尽管time.Sleep()也能解决问题，但需要注意的是，引入睡眠可能会增加循环的延迟，影响程序的响应速度。选择合适的睡眠时间至关重要，过长会降低响应性，过短可能效果不明显（但在大多数情况下，即使是time.Sleep(0)也能触发调度）。

注意事项与总结

• select本身不是问题： 问题的根源不在于select语句本身，而在于其default分支在一个忙循环中没有提供调度点。
• 避免纯计算忙循环： 在编写高并发Go程序时，应尽量避免在主循环中创建纯计算的忙循环，尤其是在没有明确调度点的情况下。
• 选择合适的调度策略：
  • 如果你的default分支确实需要执行一些非阻塞的计算，但又需要确保其他协程有机会运行，那么runtime.Gosched()是最佳选择。
  • 如果你的程序在default分支中确实需要等待一段时间，time.Sleep()是合适的。
  • 如果你的default分支自然包含I/O操作（如日志记录、网络发送等），通常不需要额外处理，因为这些操作会隐式触发调度。
• 性能考量： 频繁调用runtime.Gosched()或time.Sleep(0)可能会引入轻微的调度开销，但在解决协程饥饿问题时，这种开销通常是值得的。

通过理解Go协程调度的工作原理，并合理利用runtime.Gosched()、time.Sleep()或确保I/O操作的存在，我们可以有效避免select忙循环导致的协程饥饿问题，从而构建出更健壮、响应更快的并发Go应用程序。