深入理解 Go 调度循环:schedule 如何在一轮又一轮的调度中运转
深入理解 Go 调度循环:schedule 如何在一轮又一轮的调度中运转
导读
Go 运行时(Runtime)的核心工作之一,就是通过调度器(Scheduler)将可运行的 goroutine 安排到工作线程(M)上执行。本文基于 go-questions 仓库 content/sched/12-schedule 循环如何运转.md 展开,完整梳理一条调度循环的调用链——从 schedule() 选中 goroutine 开始,经过 execute()、gogo() 完成栈与执行权的切换,再到 goroutine 执行完毕后经由 goexit() 系列清理函数重新回到 schedule()。读完本文,你将理解:调度循环的完整形态、g0 栈与用户 goroutine 栈是如何反复切换的,以及"永远不返回的函数调用"为何不会耗尽 g0 的栈空间。
调度循环的全貌:一次闭环的调用链
在 goroutine 如何退出 一节中我们了解到:main goroutine 执行完 runtime.main 后直接调用 exit(0) 使整个进程退出;而普通 goroutine(记为 gp)执行完后,会经过一系列清理调用,最终切回 g0 栈再次执行 schedule 函数。普通 goroutine 正是在 schedule 函数中被选中,才有机会上 CPU 执行;而它执行完后又再次进入 schedule,这就形成了一个循环。
整体调用链如下:
schedule() -> execute() -> gogo() -> goroutine 任务 -> goexit() -> goexit1() -> mcall() -> goexit0() -> schedule()
上图(取自 content/sched/assets/3.png)左侧是调度执行的完整流程,右侧是与之对应的栈结构,可以从三个层面解读:
- 启动阶段:
rt0_go负责 Go 程序启动的所有初始化。在调用mstart之前,执行流已经切换到 g0 栈;图中不同色块表示不同栈空间——白色对应主线程栈,橙色对应 g0 栈,绿色对应用户 goroutine 栈。 - 切换阶段:接着调用
gogo函数,完成从 g0 栈到用户 goroutine 栈的切换,无论对 main goroutine 还是普通 goroutine 都一样。 - 执行与回收阶段:执行 main 函数或用户自定义的 goroutine 任务;执行完成后,main goroutine 直接调用
exit(0)退出,普通 goroutine 则调用goexit -> goexit1 -> mcall完成清理,再切回 g0 栈调用goexit0,将普通 goroutine 加入缓存池后调用schedule进行新一轮调度。
可以这样定义:一轮调度从调用 schedule 函数开始,经过一系列过程再次调用 schedule 函数进行新一轮调度,从一轮调度到新一轮调度的过程就是一个调度循环。
这里有两个关键限定:
- 调度循环是针对单个工作线程而言的。同一个 Go 程序中存在多个工作线程,每个工作线程都在进行自己的调度循环。
- 栈空间的划分。调用链中
goroutine 任务 -> goexit() -> goexit1() -> mcall()是在用户 goroutine 的栈(例如 g2 的栈)上执行的,而其余函数全部在 g0 栈上执行。
每一轮循环从 schedule 开始:找到可以运行的 goroutine
schedule 函数定义于 runtime/proc.go,注释明确写着"执行一轮调度器的工作:找到一个 runnable 的 goroutine,并且执行它,永不返回"。在 schedule 循环如何启动 一节中可以看到,工作线程在 mstart1() 中保存好 g0 的调度信息(gosave(&_g_.m.g0.sched))后,就直接进入 schedule()。
schedule 的核心是"找 G",遵循三级递进的策略(详见 M 如何找工作):
top:
// 1. 为了公平,每调用 schedule 函数 61 次就要从全局可运行 goroutine 队列中获取
if _g_.m.p.ptr().schedtick%61 == 0 && sched.runqsize > 0 {
lock(&sched.lock)
gp = globrunqget(_g_.m.p.ptr(), 1) // 从全局队列最大获取 1 个 goroutine
unlock(&sched.lock)
}
// 2. 从 P 本地获取 G 任务
if gp == nil {
gp, inheritTime = runqget(_g_.m.p.ptr())
}
// 3. 从其它工作线程的运行队列中偷取;偷不到则当前工作线程进入睡眠
if gp == nil {
gp, inheritTime = findrunnable() // blocks until work is available
}
// ...
execute(gp, inheritTime)
要点解读:
- 本地优先、全局保底:优先取 P 的本地运行队列
runqget;但为了公平,调度器每调度 61 次(schedtick%61 == 0)且全局队列非空时,会先从全局队列globrunqget取 1 个 goroutine,避免两个 goroutine 互相创建对方而长期独占本地队列。 - 没活就去"偷":本地、全局都找不到时调用
findrunnable,它会尝试从其它 P 偷取 goroutine(runqsteal/runqgrab),实在偷不到就把 P 放回全局空闲链表、让 M 通过notesleep/futex休眠,直到被唤醒(这一整套"找工作"的细节可参考 M 如何找工作)。 - execute 是真正的交接:找到 gp 后调用
execute(gp, inheritTime)。
execute 与 gogo:从 g0 栈切到用户栈
execute 函数负责把选中的 goroutine 送上 CPU:
// 调度 gp 在当前 M 上运行
func execute(gp *g, inheritTime bool) {
_g_ := getg() // g0
casgstatus(gp, _Grunnable, _Grunning) // 将 gp 的状态改为 running
gp.waitsince = 0
gp.preempt = false
gp.stackguard0 = gp.stack.lo + _StackGuard
if !inheritTime {
_g_.m.p.ptr().schedtick++ // 调度器调度次数增加 1
}
_g_.m.curg = gp // 将 gp 和 m 关联起来
gp.m = _g_.m
// ...
gogo(&gp.sched) // 完成从 g0 到 gp 真正的切换
}
注意两点:一是如果 inheritTime 为真,gp 继承上一个 goroutine 剩余的"时间片",否则开启新的时间片,并给 P 的 schedtick 加一;二是 execute 本身运行在 g0 栈上(此时函数调用栈使用的是 g0 的栈空间),真正跳到 gp 的代码和栈空间去运行,靠的是最后的 gogo。
gogo 必须用汇编编写,因为 goroutine 的调度涉及不同执行流之间的切换。执行流切换的本质是 CPU 寄存器与函数调用栈的切换,而 Go、C 这类高级语言都无法精确控制 CPU 寄存器,只能依靠汇编指令来完成。gogo(runtime/asm_amd64.s)的核心步骤是:
MOVQ gobuf_g(BX), DX // DX = gp.sched.g
get_tls(CX)
MOVQ DX, g(CX) // 把要运行的 g 的指针放入线程本地存储 tls[0]
MOVQ gobuf_sp(BX), SP // 把 CPU 的 SP 寄存器设置为 sched.sp,完成栈切换
MOVQ gobuf_ret(BX), AX
MOVQ gobuf_ctxt(BX), DX
MOVQ gobuf_bp(BX), BP
// 清空 sched 中已恢复的字段,帮助垃圾回收
MOVQ $0, gobuf_sp(BX)
MOVQ $0, gobuf_ret(BX)
MOVQ $0, gobuf_ctxt(BX)
MOVQ $0, gobuf_bp(BX)
MOVQ gobuf_pc(BX), BX // 把 sched.pc 值放入 BX 寄存器
JMP BX // CPU 跳转到该地址继续执行指令
其中最关键的两步:
- 把目标 goroutine 写入 TLS:
gobuf_g(BX)中保存的是 gp 的地址,写入tls[0]后,下次再调用get_tls取出的就是 gp 而不是 g0——这标志"当前执行者"从 g0 变成了 gp。 - 恢复 SP 与 PC:
gobuf_sp(BX)被恢复进 SP 寄存器完成栈的切换(从 g0 栈切到用户 goroutine 栈),gobuf_pc(BX)放入 BX 寄存器后由JMP BX跳转执行。
从 g0 栈何用户栈如何切换 一节的 gostartcall 分析可知,gp.sched.pc 在 goroutine 创建时被设置为 funcPC(goexit) + sys.PCQuantum,随后 gostartcall 又用"偷天换日"的手法把真正的入口函数地址(如 runtime.main)填进 buf.pc,同时把 goexit 的第二条指令地址压入用户栈顶作为"返回地址"。于是 goroutine 执行完任务后,RET 指令弹出栈顶地址,CPU 会"自然而然"地跳转到 goexit,这是理解 goroutine 退出流程的关键伏笔。
任务执行完毕:goroutine 如何回到调度循环
goroutine 任务执行完后的去向,决定了调度循环能否闭合。main goroutine 与普通 goroutine 走了完全不同的两条路(详见 goroutine 如何退出):
main goroutine:直接 exit(0),不参与循环
runtime.main 执行完用户 main 函数后,直接进入系统调用 exit(0) 退出整个进程,之后还有一段保护性代码(往空指针写入)让进程在意外返回时 crash。也就是说 main goroutine 并没有返回,也没有经过 goexit,因为当初跳转到 runtime.main 用的是 JMP 而非 CALL,根本没有可返回的地址。
例如下面的程序,main goroutine 退出时 go 出去的打印语句根本来不及执行:
package main
import "fmt"
func main() {
go func() {fmt.Println("hello")}()
}
普通 goroutine:goexit 系列清理后重回 schedule
普通 goroutine(gp)执行完后,RET 指令弹出 funcPC(goexit)+1,CPU 跳到 goexit 的第二条指令继续执行:
// src/runtime/asm_amd64.s
TEXT runtime·goexit(SB),NOSPLIT,$0-0
BYTE $0x90 // NOP
CALL runtime·goexit1(SB) // does not return
BYTE $0x90 // NOP
goexit1 随即调用 mcall(goexit0):
// src/runtime/proc.go
// Finishes execution of the current goroutine.
func goexit1() {
// ...
mcall(goexit0)
}
mcall(runtime/asm_amd64.s)是"从用户栈切回 g0 栈"的枢纽,它做了三件事:
- 保存 gp 的现场:把 mcall 的返回地址、当前 SP、BP、g 分别存入
gp.sched的pc、sp、bp、g字段; - 切换栈:把 TLS 中的 g 换成
m.g0,并把SP设为g0.sched.sp,由此从 gp 的栈切换到 g0 的栈; - 调用 goexit0:以 gp 为参数调用
goexit0(gp)——注意它"永远都不会返回",所以汇编里 CALL 指令后面还安排了badmcall2来处理意外返回的情况。
goexit0 运行在 g0 栈上,是 goroutine 的"最终告别仪式":
// goexit continuation on g0.
func goexit0(gp *g) {
_g_ := getg() // g0
casgstatus(gp, _Grunning, _Gdead)
if isSystemGoroutine(gp) {
atomic.Xadd(&sched.ngsys, -1)
}
// 清空 gp 的一些字段
gp.m = nil
gp.lockedm = nil
_g_.m.lockedg = nil
// ... 其余字段置零 ...
gp.gcscanvalid = true
dropg() // 解除 g 与 m 的关系(g->m = nil, m->currg = nil)
_g_.m.locked = 0
gfput(_g_.m.p.ptr(), gp) // 将 g 放入 free 队列缓存起来
schedule() // 再次进行调度
}
它完成的清理工作可归纳为五点:
- 把 g 的状态从
_Grunning更新为_Gdead; - 清空 g 的一系列字段(
m、lockedm、_defer、_panic、writebuf、param、labels、timer等); - 调用
dropg解除 g 和 m 的关系,即设置g->m = nil、m->currg = nil; - 调用
gfput把 g 放入 p 的gfree队列缓存起来,供下次创建 goroutine 时快速复用,避免重新分配内存; - 调用
schedule()再次进入调度循环。
至此,gp"功成身退"进入 goroutine 缓存池,而工作线程则在 g0 栈上开始了新一轮 schedule,循环闭合。
为什么"永不返回"的调用链不会耗尽 g0 栈
现在回到一个最容易被问住的问题:一个复杂程序中,调度可能进行无数次循环,也就是无数次没有返回的函数调用。众所周知,每次函数调用都会消耗一定栈空间,照这样无返回地调用下去,无论 g0 有多大栈空间终究会耗尽——这里是不是有问题?
答案是没有问题,关键就在 mcall 每次切换到 g0 栈时,都切到 g0.sched.sp 所指的固定位置。
回忆 schedule 循环如何启动 中的 mstart1:
// Record top of stack for use by mcall.
// Once we call schedule we're never coming back,
// so other calls can reuse this stack space.
// 一旦调用 schedule() 函数,永不返回,所以栈帧可以被复用
gosave(&_g_.m.g0.sched)
_g_.m.g0.sched.pc = ^uintptr(0) // make sure it is never used
// ...
schedule()
gosave 把 mstart1 栈帧上的 SP 保存在了 g0.sched.sp 中。此后每一轮调度循环,mcall 切换回 g0 栈时都是直接把 SP 设置到这个固定位置,相当于"每次都在同一块栈内存上重新开始"。
为什么这样行得通?要点如下:
- 栈的增大与减小本质是 SP 的变化:调用函数时栈空间自动"增大"(SP 下移),函数返回时自动"减小"(SP 上移)。
- 这一系列函数永远不返回:从
schedule开始之后的函数(schedule -> execute -> gogo以及goexit -> goexit1 -> mcall -> goexit0 -> schedule)都不需要回到调用者,调用者不需要被调用者的返回值,形态上很像"尾递归"。 - g0 一直没有被"永久占用":因为 g0 从未真正"离开"并再次进入同一深度的调用,它之前保存的
sp依然有效。每次mcall都从g0.sched.sp重新开始压栈,新一轮调度循环会覆盖上一轮调度循环的栈数据,周而复始、完美复用。
这也解释了 schedule 循环如何运转 原文档中所说的:"每次执行 mcall 切换到 g0 栈时都是切换到 g0.sched.sp 所指的固定位置,因为从 schedule 函数开始之后的一系列函数永远都不会返回,所以重用这些函数上一轮调度时所使用过的栈内存是没有问题的"。g0 栈因此不存在"越积越深"的问题,无限循环也不会导致栈溢出。
不止一个循环:每个工作线程都有自己的调度循环
需要特别强调的是,上面的"循环"描述的是某一个工作线程(M)的调度循环。Go 程序中通常有多个工作线程同时存在,每个 M 都在进行着自己独立的调度循环。
- 在 GPM 是什么 一节可以看到,M 必须绑定 P 才能执行 goroutine;P 的本地运行队列(
runq,容量 256 的循环队列)和runnext是各循环取 G 的首要来源。 - 当 M 自己的本地队列没有工作时,会进入 M 如何找工作 描述的"自旋"流程:检查全局队列、扫描 network poller、去其它 P 偷工作(
runqsteal/runqgrab),偷不到就stopm休眠等待唤醒。 - M 的状态只有自旋与非自旋两种:自旋时努力找工作,找不到进入非自旋并休眠,直到有工作后被其它线程唤醒再次自旋。
因此,一个 Go 程序的"调度"实际是多个调度循环并发交织的结果。每一轮循环内部都是"找 G → 切栈执行 → 清理退出 → 再找 G"的闭环,而 M 之间通过全局运行队列、P 的交接与工作窃取彼此协作,共同构成 Go 运行时高效的调度体系。
总结
梳理一遍完整的调度循环:
- 工作线程在
mstart1中通过gosave保存g0.sched.sp,进入schedule()后永不返回; schedule()依次尝试本地队列runqget、定期从全局队列globrunqget、以及findrunnable偷取/休眠,最终选中一个可运行 goroutine;execute()将 goroutine 状态置为_Grunning、关联 m 与 g,并通过汇编gogo()恢复sched.sp/sched.pc,完成从 g0 栈到用户栈的切换;- 用户任务执行完毕后,RET 弹出栈顶的
goexit地址,普通 goroutine 走goexit -> goexit1 -> mcall -> goexit0:保存现场、切回 g0 栈、清理字段、把 g 放入缓存池,最后再次调用schedule(); - 因为
schedule之后的函数全部不返回,每次mcall都从g0.sched.sp这个固定位置重新使用栈内存,所以无论调度多少轮,g0 栈都不会被耗尽。
这就是 Go 调度循环运转的核心机制——一个"永不停歇、永不返回、栈被循环复用"的精密闭环。
