深入理解 Go 调度循环:schedule 如何在一轮又一轮的调度中运转

原创2026-10-08 21:35:571,838 阅读
文章标签:文档教程技术博客

深入理解 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()

Go 调度循环流程图

上图(取自 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 函数进行新一轮调度,从一轮调度到新一轮调度的过程就是一个调度循环。

这里有两个关键限定:

  1. 调度循环是针对单个工作线程而言的。同一个 Go 程序中存在多个工作线程,每个工作线程都在进行自己的调度循环。
  2. 栈空间的划分。调用链中 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 跳转到该地址继续执行指令

其中最关键的两步:

  1. 把目标 goroutine 写入 TLS:gobuf_g(BX) 中保存的是 gp 的地址,写入 tls[0] 后,下次再调用 get_tls 取出的就是 gp 而不是 g0——这标志"当前执行者"从 g0 变成了 gp。
  2. 恢复 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 栈"的枢纽,它做了三件事:

  1. 保存 gp 的现场:把 mcall 的返回地址、当前 SP、BP、g 分别存入 gp.sched 的 pc、sp、bp、g 字段;
  2. 切换栈:把 TLS 中的 g 换成 m.g0,并把 SP 设为 g0.sched.sp,由此从 gp 的栈切换到 g0 的栈;
  3. 调用 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()                 // 再次进行调度
}

它完成的清理工作可归纳为五点:

  1. 把 g 的状态从 _Grunning 更新为 _Gdead;
  2. 清空 g 的一系列字段(m、lockedm、_defer、_panic、writebuf、param、labels、timer 等);
  3. 调用 dropg 解除 g 和 m 的关系,即设置 g->m = nil、m->currg = nil;
  4. 调用 gfput 把 g 放入 p 的 gfree 队列缓存起来,供下次创建 goroutine 时快速复用,避免重新分配内存;
  5. 调用 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 运行时高效的调度体系。


总结

梳理一遍完整的调度循环:

  1. 工作线程在 mstart1 中通过 gosave 保存 g0.sched.sp,进入 schedule() 后永不返回;
  2. schedule() 依次尝试本地队列 runqget、定期从全局队列 globrunqget、以及 findrunnable 偷取/休眠,最终选中一个可运行 goroutine;
  3. execute() 将 goroutine 状态置为 _Grunning、关联 m 与 g,并通过汇编 gogo() 恢复 sched.sp/sched.pc,完成从 g0 栈到用户栈的切换;
  4. 用户任务执行完毕后,RET 弹出栈顶的 goexit 地址,普通 goroutine 走 goexit -> goexit1 -> mcall -> goexit0:保存现场、切回 g0 栈、清理字段、把 g 放入缓存池,最后再次调用 schedule();
  5. 因为 schedule 之后的函数全部不返回,每次 mcall 都从 g0.sched.sp 这个固定位置重新使用栈内存,所以无论调度多少轮,g0 栈都不会被耗尽。

这就是 Go 调度循环运转的核心机制——一个"永不停歇、永不返回、栈被循环复用"的精密闭环。

登录后查看全文
go-questions