原创文章，欢迎转载，转载请注明出处，谢谢。
0. 前言
在 Go runtime 调度器精讲（七）：案例分析 一文我们介绍了一个抢占的案例。从案例分析抢占的实现，并未涉及到源码层面。本文将继续从源码入手，看 Go runtime 调度器是如何实现抢占逻辑的。
1. sysmon 线程
还记得 Go runtime 调度器精讲（四）：运行 main goroutine 一文我们蜻蜓点水的提了一嘴 sysmon 线程，它是运行在系统栈上的监控线程，负责监控 goroutine 的状态，并且做相应处理。当然，也负责做抢占的处理，它是本讲的重点。
sysmon 的创建在 src/runtime/proc.go:sysmon：
// The main goroutine. func main() { ... if GOARCH != "wasm" { // no threads on wasm yet, so no sysmon systemstack(func() { newm(sysmon, nil, -1) }) } ... } sysmon 不需要和 P 绑定，作为监控线程运行在系统栈。进入 sysmon：
func sysmon() { ... idle := 0 // how many cycles in succession we had not wokeup somebody delay := uint32(0) for { if idle == 0 { // start with 20us sleep... delay = 20 // } else if idle > 50 { // start doubling the sleep after 1ms... delay *= 2 } if delay > 10*1000 { // up to 10ms delay = 10 * 1000 } usleep(delay) // 休眠 delay us // retake P's blocked in syscalls // and preempt long running G's if retake(now) != 0 { idle = 0 } else { idle++ } ... } } 省略了很多和抢占无关的内容，和抢占相关的是 retake 函数，进入 retake：
func retake(now int64) uint32 { n := 0 lock(&allpLock) // 。。。 for i := 0; i < len(allp); i++ { if pp == nil { // This can happen if procresize has grown // allp but not yet created new Ps. continue } pd := &pp.sysmontick // 用于 sysmon 线程记录被监控 p 的系统调用次数和调用时间 s := pp.status sysretake := false if s == _Prunning || s == _Psyscall { // 如果 P 是 _Prunning 或者 _Psyscall，则对 P 进行处理 // Preempt G if it's running for too long. t := int64(pp.schedtick) // P 的 schedtick 用于记录 P 被调度的次数 if int64(pd.schedtick) != t { pd.schedtick = uint32(t) // 如果系统监控和调度次数不一致，则更新系统监控的调度次数和调度时间点 pd.schedwhen = now } else if pd.schedwhen+forcePreemptNS <= now { // forcePreemptNS 为 10ms，如果 P 的 goroutine 运行时间超过 10ms 则对 P 发起抢占 preemptone(pp) // 抢占 P // In case of syscall, preemptone() doesn't // work, because there is no M wired to P. sysretake = true // 设置 retake 标志为 true } } ... } unlock(&allpLock) return uint32(n) } 这里重点在如果 P 的 goroutine 运行时间过长，则进入 preemptone(pp) 抢占 P，也就是抢占运行时间过长的 goroutine。
1.1 抢占运行时间过长的 goroutine
进入 preemptone：
func preemptone(pp *p) bool { mp := pp.m.ptr() // P 绑定的线程 if mp == nil || mp == getg().m { return false } gp := mp.curg // 线程运行的 goroutine，就是该 goroutine 运行过长的 if gp == nil || gp == mp.g0 { return false } gp.preempt = true // 设置抢占标志位为 true // Every call in a goroutine checks for stack overflow by // comparing the current stack pointer to gp->stackguard0. // Setting gp->stackguard0 to StackPreempt folds // preemption into the normal stack overflow check. gp.stackguard0 = stackPreempt // 官方的注释已经很清晰了，设置 goroutine 的 stackguard0 为 stackPreempt，stackPreempt 是一个比任何栈都大的数 // Request an async preemption of this P. if preemptMSupported && debug.asyncpreemptoff == 0 { // 是否开启异步抢占，这里我们先忽略 pp.preempt = true preemptM(mp) } return true } 可以看到，preemptone 主要是更新了 goroutine 的 gp.stackguard0，为什么更新这个呢？
主要是在下一次调用函数时，调度器会根据这个值判断是否应该抢占当前 goroutine。
我们看一个 goroutine 栈如下：
func gpm() { print("hello runtime") } func main() { go gpm() time.Sleep(1 * time.Minute) print("hello main") } 给 goroutine 加断点，dlv 进入断点处：
(dlv) b main.gpm Breakpoint 1 set at 0x46232a for main.gpm() ./main.go:5 (dlv) c > main.gpm() ./main.go:5 (hits goroutine(5):1 total:1) (PC: 0x46232a) 1: package main 2: 3: import "time" 4: => 5: func gpm() { 6: print("hello runtime") 7: } 8: 9: func main() { 10: go gpm() (dlv) disass TEXT main.gpm(SB) /root/go/src/foundation/gpm/main.go main.go:5 0x462320 493b6610 cmp rsp, qword ptr [r14+0x10] main.go:5 0x462324 762a jbe 0x462350 main.go:5 0x462326 55 push rbp main.go:5 0x462327 4889e5 mov rbp, rsp => main.go:5 0x46232a* 4883ec10 sub rsp, 0x10 main.go:6 0x46232e e82d28fdff call $runtime.printlock ... main.go:5 0x462350 e8abb1ffff call $runtime.morestack_noctxt main.go:5 0x462355 ebc9 jmp $main.gpm 在 main.gpm 栈中，首先执行 cmp rsp, qword ptr [r14+0x10] 指令，这个指令的意思是将当前栈的栈顶和 [r14+0x10] 比较，[r14+0x10] 就是 goroutine 的 stackguard0 值。如果 rsp 大于 g.stackguard0 表示栈容量是足够的，如果小于 g.stackguard0 表示栈空间不足，需要执行 jbe 0x462350 跳转指令，调用 call $runtime.morestack_noctxt 扩栈。
这里如果 goroutine 是要被抢占的，那么 g.stackguard0 将被 sysmon 设置成很大的值。goroutine（中的函数） 在调用时，会执行 cmp rsp, qword ptr [r14+0x10] 指令比较栈顶指针和 g.stackguard0。因为栈顶 rsp 肯定小于 g.stackguard0，调用 call $runtime.morestack_noctxt 扩栈。
// morestack but not preserving ctxt. TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0 MOVL $0, DX JMP runtime·morestack(SB) TEXT runtime·morestack(SB),NOSPLIT|NOFRAME,$0-0 ... // runtime.morestack 内容很多，这里只挑重点和抢占相关的 runtime.newstack 介绍 BL runtime·newstack(SB) ... 进入 runtime.newstack：
func newstack() { thisg := getg() ... gp := thisg.m.curg ... stackguard0 := atomic.Loaduintptr(&gp.stackguard0) preempt := stackguard0 == stackPreempt // 如果 gp.stackguard0 == stackPreempt，则设置抢占标志 preempt == true if preempt { if !canPreemptM(thisg.m) { // 判断是否可以抢占 // Let the goroutine keep running for now. // gp->preempt is set, so it will be preempted next time. gp.stackguard0 = gp.stack.lo + stackGuard // 如果不能抢占，恢复 gp.stackguard0 为正常值 gogo(&gp.sched) // never return // gogo 执行 goroutine } } ... if preempt { // 执行到这里，说明 goroutine 是可以抢占的，再次判断抢占标志是否为 true if gp == thisg.m.g0 { throw("runtime: preempt g0") } if thisg.m.p == 0 && thisg.m.locks == 0 { throw("runtime: g is running but p is not") } ... if gp.preemptStop { // 判断抢占类型是否是 preemptStop，这个类型和 GC 有关，这里我们不讨论 preemptPark(gp) // never returns } // Act like goroutine called runtime.Gosched. gopreempt_m(gp) // never return // 重点看 gopreempt_m 进行的抢占 } ... } newstack 会执行抢占逻辑，如注释所示，经过层层执行，调用 gopreempt_m 抢占运行时间过长的 goroutine：
func gopreempt_m(gp *g) { goschedImpl(gp) } func goschedImpl(gp *g) { status := readgstatus(gp) // 获取 goroutine 的状态 if status&^_Gscan != _Grunning { dumpgstatus(gp) throw("bad g status") } casgstatus(gp, _Grunning, _Grunnable) // 这时候 goroutine 还是运行的，更新 goroutine 的状态为 _Grunnable dropg() // 调用 dropg 解除线程和 goroutine 的绑定 lock(&sched.lock) globrunqput(gp) // 将 goroutine 放到全局可运行队列中，因为 goroutine 运行时间够长了，不会放到 P 的本地队列中，这也是一种惩罚机制吧 unlock(&sched.lock) schedule() // 线程再次进入调度逻辑，运行下一个 _Grunnable 的 goroutine } 至此，我们知道对于运行时间过长的 goroutine 是怎么抢占的。
再次梳理下执行流程：
sysmon监控线程发现运行时间过长的 goroutine，将 goroutine 的 stackguard0 更新为一个比任何栈都大的 stackPreempt 值- 当线程进行函数调用时，会比较栈顶 rsp 和 g.stackguard0 检查 goroutine 栈的栈空间。
- 因为更新了 goroutine 栈的
stackguard0，线程会走到扩展逻辑，进入根据 preempt 标志位，执行对应的抢占调度。
2. 小结
本讲介绍了 sysmon 线程，顺着 sysmon 线程介绍了抢占运行时间过长的 goroutine 的实现方式。下一讲会继续介绍 sysmon 线程和抢占系统调用时间过长的 goroutine。
