观察一下Go的异步抢占

Go在1.14版本加入了异步抢占机制. 下面的例子可能会让你了解加入异步抢占之后部分Go程序的行为变化:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import (
"runtime"
)

func main() {
runtime.GOMAXPROCS(1)

go func() {
panic("boom")
}()

for {
}
}

当在Go1.14版本之前编译并执行这段程序时, 你会发现该程序永远不会panic. 而在Go1.14版本之后, goroutine中的panic会被执行. 如果你的设备中已经使用了Go1.14及更高的版本, 你可以使用

GODEBUG=asyncpreemptoff=1 go run main.go 来运行该段程序来模拟Go之前版本的行为, 其中GODEBUG=asyncpreemptoff=1参数显示指定了关闭异步抢占功能.

Go在之前版本中就已经实现了抢占调度, 当一个goroutine进行系统调用等操作时, 该goroutine会被抢占. 但有些场景无法抢占成功, 比如轮询计算 for { i++ } 等. Go team已经意识到抢占是个问题, 所以在1.14中加入了基于信号的协程调度抢占. 原理是这样的, 首先注册绑定 SIGURG 信号及处理方法 runtime.doSigPreempt , sysmon 会间隔性检测超时的P, 然后发送信号, M收到信号后休眠执行的goroutine并且进行重新调度.

我们可以通过 go tool trace 可视化这一过程以便观察.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package main

import (
"os"
"runtime"
"runtime/trace"
"sync"
)

var wg sync.WaitGroup

// GODEBUG=asyncpreemptoff=1 go run main.go
func main() {
runtime.GOMAXPROCS(1)

f, _ := os.Create("trace.dat")
defer f.Close()

_ = trace.Start(f)
defer trace.Stop()

for i := 0;i < 20;i++ {
wg.Add(1)
go func() {
defer wg.Done()
t := 0
for i := 0;i < 1e9;i++ {
t += 2
}
}()
}
wg.Wait()
}

为了更清楚的看到调度过程, 我们设置 runtime.GOMAXPROCS(1) 来确保该程序只会利用到单核进行计算.

我们先来看一下1.14之前的现象:

1
2
GODEBUG=asyncpreemptoff=1 go run main.go
go tool trace trace.dat

可以看到各个goroutine串行调度, 单个goroutine的执行时间达到了200ms级别.

再来看看1.14的表现:

1
2
go run main.go
go tool trace trace.dat

可以看到一个goroutine在执行了10|20ms后, 就会被其他goroutine抢占. 而下方 End Stack Trace 中切出的栈变为了 runtime.asyncPreempt:50 , 代表该次切换为异步抢占.

不同的情况下运行该程序的耗时基本是一致的, 异步抢占这种协程调度本质上是为了增加系统的吞吐能力. 抢占型调度是为了让大家公平的得到调度, 不会让系统因为某一个协程卡死(因为处理器资源有限). 举个例子:

假设:

  1. 只有一个处理器(GOMAXPROCS = 1)
  2. G1, G2, G3, G4 依次在调度队列里, 并且这个协程都是纯计算的逻辑
  3. G1 执行需要 1 小时, G2 执行需要 0.02 秒, G3 执行需要 0.02 秒, G4 执行需要 0.01 秒

如果是 Go1.13 这样不可抢占的模式, 先执行 G1, 那么一个小时之后再执行 G2, G3, G4, 这段时间不能执行任何逻辑, 相当于系统卡死 1 小时, 1小时内无作为(并且还会堆积请求), 系统吞吐率极低.

如果是 Go1.14, 那么先执行 G1, 20ms之后, 让出调度权, 依次执行 G2, G3, G4 瞬间就完成了, 并且之后有新的请求来, 系统还是可以响应的, 吞吐率高. 尤其是在 IO 操作的情况, 其实只需要一点点 CPU 就行了, 这些抢占过来的 CPU 能够用在很多更有效的场景.

Ref