Go 调度器系列:schedule 循环如何启动 —— 从 mstart 到 gogo 的首次上下文切换

原创2026-10-08 21:33:061,993 阅读
文章标签:文档教程技术博客

Go 调度器系列:schedule 循环如何启动 —— 从 mstart 到 gogo 的首次上下文切换

在 go-questions 的调度器专题中,前面已经完成了 GPM 模型、调度器初始化(schedinit)与 main goroutine 创建(newproc)的讲解;本文接着这条主线,深入剖析 schedule 调度循环的启动过程:主线程如何通过 mstart → mstart1 → gosave → schedule → execute → gogo 这一调用链,从 g0 系统栈完成到 main goroutine 的第一次上下文切换。读完本文,你将彻底理解 Go 调度循环的入口链路、gobuf 调度信息的保存与恢复,以及 plan9 汇编中 gogo 为何必须用汇编实现寄存器与栈的切换。

回顾:我们走到了 rt0_go 的最后一步

上一讲(main goroutine 如何创建)新创建了一个 goroutine,设置好了 sched 成员的 sp 和 pc 字段,并且将其添加到了 p0 的本地可运行队列,坐等调度器的调度。

我们继续看代码。搞了半天,其实还停留在 runtime·rt0_go 函数里:执行完 runtime·newproc(SB) 后,两条 POPQ 指令将之前为调用它构建的参数弹出栈。好消息是,最后就只剩下一个函数了:

// start this M
// 主线程进入调度循环,运行刚刚创建的 goroutine
CALL	runtime·mstart(SB)

这正是本系列的核心区。前面铺垫了这么多——g0 栈的初始化、主线程与 m0/g0 的绑定、调度器结构体 schedt 的初始化、main goroutine 的诞生——调度器终于要开始运转了。整个启动链条可参考 描述 scheduler 的初始化过程 中的 rt0_go 完整汇编:osinit → schedinit → newproc → mstart,而 mstart 正是从"初始化阶段"跨入"调度阶段"的那道分水岭。

mstart 与 mstart1:进入调度循环前的最后准备

mstart 函数设置了 stackguard0 和 stackguard1 字段后,就直接调用 mstart1() 函数:

func mstart1() {
	// 启动过程时 _g_ = m0.g0
	_g_ := getg()

	if _g_ != _g_.m.g0 {
		throw("bad runtime·mstart")
	}

	// 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
	asminit()
	minit()

	// ……………………

	// 执行启动函数。初始化过程中,fn == nil
	if fn := _g_.m.mstartfn; fn != nil {
		fn()
	}

	if _g_.m.helpgc != 0 {
		_g_.m.helpgc = 0
		stopm()
	} else if _g_.m != &m0 {
		acquirep(_g_.m.nextp.ptr())
		_g_.m.nextp = 0
	}

	// 进入调度循环。永不返回
	schedule()
}

几个值得注意的细节:

  • _g_ := getg() 在启动场景下取到的是 m0.g0,因此开头的 if _g_ != _g_.m.g0 校验保证了 mstart1 必须在 g0 栈上执行——调度器代码全部运行在 g0 栈,这是理解整个调度循环的前提。
  • gosave 先把当前 g0 的执行现场(sp/pc 等)保存到 g0.sched,紧接着又把 _g_.m.g0.sched.pc 强制置为 ^uintptr(0)。注释说得很明白:一旦调用 schedule() 就永不返回,所以 g0 栈帧可以被后续每一轮调度复用。
  • 初始化场景下 mstartfn == nil,所以启动函数分支不执行;且 _g_.m == &m0,所以 acquirep 分支同样跳过(m0 在 schedinit → procresize 阶段已经通过 acquirep 绑定了 p0)。
  • 最后一行 schedule() 是永不出站的调用,一旦进入,当前工作线程就正式切换为"调度器"身份。

gosave:把 g0 的执行现场记入 gobuf

调用 gosave 函数来保存调度信息到 g0.sched 结构体。gosave 是汇编实现,本质上是一个 setjmp——把当前 CPU 的关键寄存器值快照到 gobuf:

// void gosave(Gobuf*)
// save state in Gobuf; setjmp
TEXT runtime·gosave(SB), NOSPLIT, $0-8
	// 将 gobuf 赋值给 AX
	MOVQ    buf+0(FP), AX       // gobuf
	// 取参数地址,也就是 caller 的 SP
	LEAQ    buf+0(FP), BX       // caller's SP
	// 保存 caller's SP,再次运行时的栈顶
	MOVQ    BX, gobuf_sp(AX)
	MOVQ    0(SP), BX       // caller's PC
	// 保存 caller's PC,再次运行时的指令地址
	MOVQ    BX, gobuf_pc(AX)
	MOVQ    $0, gobuf_ret(AX)
	MOVQ    BP, gobuf_bp(AX)
	// Assert ctxt is zero. See func save.
	MOVQ    gobuf_ctxt(AX), BX
	TESTQ   BX, BX
	JZ  2(PC)
	CALL    runtime·badctxt(SB)
	// 获取 tls
	get_tls(CX)
	// 将 g 的地址存入 BX
	MOVQ    g(CX), BX
	// 保存 g 的地址
	MOVQ    BX, gobuf_g(AX)
	RET

逐条看,gosave 主要做了五件事:

  1. gobuf_sp(AX) = caller's SP:LEAQ buf+0(FP), BX 取的是参数在栈上的地址,也就是 mstart1 调用 gosave 那一刻的栈顶位置,将来若想"恢复" g0 的执行,就从这个位置继续;
  2. gobuf_pc(AX) = 0(SP):0(SP) 是 CALL 指令压入的返回地址,也就是 gosave 返回后 mstart1 中要执行的下一条指令;
  3. 清零 ret、保存帧指针 bp,并断言 ctxt 为零(badctxt 是兜底错误分支);
  4. get_tls(CX) + MOVQ g(CX), BX:从线程本地存储中取出当前 g(此刻是 g0)的地址;
  5. gobuf_g(AX) = BX:把这个 g 指针一并存入 gobuf.g,保证将来恢复现场时能找回正确的 g 对象。

简化来说,gosave 之后,g0.sched 中的关键字段被设定为:sp 指向 mstart1 函数栈上参数的位置,pc 则指向 gosave 返回后的下一条指令。注意,图中 sched.pc 并不直接指向返回地址,所以图中的虚线并没有箭头:

调用 gosave 函数后 g0.sched 的 sp 与 pc 指向

这张图直观展示了 mstart1(左侧代码)调用 gosave 后,g0.sched 与 g0 栈、m0、p0 以及 allm/allp 全局链表之间的关系——g0 的执行现场被完整快照,为后面 gogo 的"一去不返"做好准备。

schedule:调度循环的核心函数

gosave 完成之后,mstart1 最后一行调用 schedule(),永不返回。schedule 函数的作用是:执行一轮调度器的工作——找到一个 runnable 的 goroutine,并且执行它:

// 执行一轮调度器的工作:找到一个 runnable 的 goroutine,并且执行它
// 永不返回
func schedule() {
	// _g_ = 每个工作线程 m 对应的 g0,初始化时是 m0 的 g0
	_g_ := getg()

	// ……………………

top:
	// ……………………

	var gp *g
	var inheritTime bool

	// ……………………

	if gp == nil {
		// Check the global runnable queue once in a while to ensure fairness.
		// Otherwise two goroutines can completely occupy the local runqueue
		// by constantly respawning each other.
		// 为了公平,每调用 schedule 函数 61 次就要从全局可运行 goroutine 队列中获取
		if _g_.m.p.ptr().schedtick%61 == 0 && sched.runqsize > 0 {
			lock(&sched.lock)
			// 从全局队列最大获取 1 个 goroutine
			gp = globrunqget(_g_.m.p.ptr(), 1)
			unlock(&sched.lock)
		}
	}

	// 从 P 本地获取 G 任务
	if gp == nil {
		gp, inheritTime = runqget(_g_.m.p.ptr())
		if gp != nil && _g_.m.spinning {
			throw("schedule: spinning with local work")
		}
	}

	if gp == nil {
		// 从本地运行队列和全局运行队列都没有找到需要运行的 goroutine,
		// 调用 findrunnable 函数从其它工作线程的运行队列中偷取,如果偷不到,则当前工作线程进入睡眠
		// 直到获取到 runnable goroutine 之后 findrunnable 函数才会返回。
		gp, inheritTime = findrunnable() // blocks until work is available
	}

	// This thread is going to run a goroutine and is not spinning anymore,
	// so if it was marked as spinning we need to reset it now and potentially
	// start a new spinning M.
	if _g_.m.spinning {
		resetspinning()
	}

	if gp.lockedm != nil {
		// Hands off own p to the locked m,
		// then blocks waiting for a new p.
		startlockedm(gp)
		goto top
	}

	// 执行 goroutine 任务函数
	// 当前运行的是 runtime 的代码,函数调用栈使用的是 g0 的栈空间
	// 调用 execute 切换到 gp 的代码和栈空间去运行
	execute(gp, inheritTime)
}

schedule 找 goroutine 遵循三级递进策略:

  1. 公平性兜底——全局队列:调度器使用 _g_.m.p.ptr().schedtick%61 == 0 判断——每调用 schedule 函数 61 次,就尝试从全局可运行队列取 1 个 goroutine(globrunqget)。注释点明了动机:如果不这样做,两个 goroutine 互相 respawn 就能把本地运行队列完全占死,全局队列里的 goroutine 将永远得不到执行机会。
  2. 本地优先——P 本地队列:调用 runqget(_g_.m.p.ptr()) 从当前 P 的本地可运行队列取出一个 g,inheritTime 表示是否继承上一轮的时间片。runqget 会优先处理具有最高优先级的 runnext 成员,其实现细节见 M 如何找工作。
  3. 穷尽手段——偷取与睡眠:本地和全局都没有时,调用 findrunnable()。它会先去别的 P 偷取工作(work stealing),偷不到就把当前工作线程休眠(stopm),直到被唤醒拿到 runnable goroutine 才返回。

在初始化场景下,main goroutine 早已在 newproc 阶段通过 runqput 进入 p0 的本地运行队列(详见 g0 栈何用户栈如何切换),因此 schedule 通常直接在第二步 runqget 就选中了 main goroutine,findrunnable 的复杂路径要到后续多 P、多 M 的运行时才会真正走上。

execute:选中 goroutine,准备移交执行权

经过千辛万苦,终于找到了可以运行的 goroutine,调用 execute(gp, inheritTime) 切换到选出的 goroutine 栈执行,调度器的调度次数会在这里更新:

// 调度 gp 在当前 M 上运行
// 如果 inheritTime 为真,gp 执行当前的时间片
// 否则,开启一个新的时间片
//
//go:yeswritebarrierrec
func execute(gp *g, inheritTime bool) {
	// g0
	_g_ := getg()

	// 将 gp 的状态改为 running
	casgstatus(gp, _Grunnable, _Grunning)
	gp.waitsince = 0
	gp.preempt = false
	gp.stackguard0 = gp.stack.lo + _StackGuard
	if !inheritTime {
		// 调度器调度次数增加 1
		_g_.m.p.ptr().schedtick++
	}

	// 将 gp 和 m 关联起来
	_g_.m.curg = gp
	gp.m = _g_.m

	// …………………………

	// gogo 完成从 g0 到 gp 真正的切换
	// CPU 执行权的转让以及栈的切换
	// 执行流的切换从本质上来说就是 CPU 寄存器以及函数调用栈的切换,
	// 然而不管是 go 还是 c 这种高级语言都无法精确控制 CPU 寄存器的修改,
	// 因而高级语言在这里也就无能为力了,只能依靠汇编指令来达成目的
	gogo(&gp.sched)
}

execute 做了三层关键动作:

  • 状态机迁移:casgstatus(gp, _Grunnable, _Grunning) 把 gp 从"可运行"改为"运行中"。同时重置 waitsince、preempt,并把 stackguard0 恢复为正常栈增长阈值(此前可能被置为 stackPreempt 以便抢占)。
  • 时间片记账:!inheritTime 时 schedtick++,这个计数器正是 schedule 中 schedtick%61 公平性判断的来源——execute 每执行一次就增加一次本 P 的调度计数。
  • 建立双向关联:_g_.m.curg = gp(m 当前运行的 goroutine)、gp.m = _g_.m(gp 归属的 m)。

最后调用 gogo(&gp.sched),完成从 g0 到 gp 的切换,CPU 的执行权将从 g0 转让给 gp。

gogo 函数也是通过汇编语言编写的,这里之所以需要使用汇编,是因为 goroutine 的调度涉及不同执行流之间的切换。前面讨论操作系统切换线程时已经看到过:执行流的切换从本质上来说就是 CPU 寄存器以及函数调用栈的切换,然而不管是 Go 还是 C 这种高级语言都无法精确控制 CPU 寄存器,因而高级语言在这里也就无能为力了,只能依靠汇编指令来达成目的。

gogo:用汇编完成从 g0 到 gp 的首次切换

继续看 gogo 函数的实现,传入 &gp.sched 参数:

TEXT runtime·gogo(SB), NOSPLIT, $16-8
	// 0(FP) 表示第一个参数,即 buf = &gp.sched
	MOVQ    buf+0(FP), BX       // gobuf

	// ……………………

	MOVQ    buf+0(FP), BX

nilctxt:
	// DX = gp.sched.g
	MOVQ    gobuf_g(BX), DX
	MOVQ    0(DX), CX       // make sure g != nil
	get_tls(CX)
	// 将 g 放入到 tls[0]
	// 把要运行的 g 的指针放入线程本地存储,这样后面的代码就可以通过线程本地存储
	// 获取到当前正在执行的 goroutine 的 g 结构体对象,从而找到与之关联的 m 和 p
	// 运行这条指令之前,线程本地存储存放的是 g0 的地址
	MOVQ    DX, g(CX)
	// 把 CPU 的 SP 寄存器设置为 sched.sp,完成了栈的切换
	MOVQ    gobuf_sp(BX), SP    // restore SP
	// 恢复调度上下文到CPU相关寄存器
	MOVQ    gobuf_ret(BX), AX
	MOVQ    gobuf_ctxt(BX), DX
	MOVQ    gobuf_bp(BX), BP
	// 清空 sched 的值,因为我们已把相关值放入 CPU 对应的寄存器了,不再需要,这样做可以少 GC 的工作量
	MOVQ    $0, gobuf_sp(BX)    // clear to help garbage collector
	MOVQ    $0, gobuf_ret(BX)
	MOVQ    $0, gobuf_ctxt(BX)
	MOVQ    $0, gobuf_bp(BX)
	// 把 sched.pc 值放入 BX 寄存器
	MOVQ    gobuf_pc(BX), BX
	// JMP 把 BX 寄存器的包含的地址值放入 CPU 的 IP 寄存器,于是,CPU 跳转到该地址继续执行指令
	JMP BX

核心的地方是:

MOVQ    gobuf_g(BX), DX
// ……
get_tls(CX)
MOVQ    DX, g(CX)

第一行,将 gp.sched.g 保存到 DX 寄存器;第二行,get_tls 将 tls 保存到 CX 寄存器,再将 gp.sched.g 放到 tls[0] 处。这样,当下次再调用 get_tls 时,取出的就是 gp,而不再是 g0。这一行完成从 g0 栈切换到 gp——它改写了线程本地存储,让后续所有 getg() 调用都能拿到正确的当前 goroutine。

接下来的指令依次完成了"上下文恢复":

指令 作用
MOVQ gobuf_sp(BX), SP 把 CPU 的 SP 寄存器设置为 sched.sp,完成栈的切换
MOVQ gobuf_ret(BX), AX 恢复系统调用返回值寄存器
MOVQ gobuf_ctxt(BX), DX 恢复上下文指针
MOVQ gobuf_bp(BX), BP 恢复帧指针
四个 MOVQ $0, gobuf_xx(BX) 清空 sched 中的快照值,减少 GC 扫描工作量
MOVQ gobuf_pc(BX), BX + JMP BX 把 sched.pc 装入 BX,再跳转到该地址

最重要的是 sched.sp 和 sched.pc:前者被恢复到 SP 寄存器(栈切换),后者被保存到 BX 寄存器,最后一条跳转指令跳转到新的地址开始执行。通过 g0 栈何用户栈如何切换 的讲解可知:newproc1 在设置 newg.sched 时调用了 gostartcallfn,把 buf.pc 指向 runtime.main,同时把 goexit 的地址"伪装"成返回地址压入栈顶——所以这里保存的正是 runtime.main 函数的地址。

最终,调度器完成了这个值得铭记的时刻,从 g0 转到 gp,开始执行 runtime.main 函数。

补充:Go plan9 汇编中的符号约定

上述汇编中经常出现类似下面的写法:

MOVQ    buf+0(FP), BX  # &gp.sched --> BX

FP 是个伪寄存器,前面加 0 表示是第一个参数的位置;最前面的 buf 表示一个符号。而 gobuf_sp(BX) 这类写法在标准 plan9 汇编中只是个 symbol、不带偏移量语义,这是 runtime 的特权——需要链接器配合,gobuf 结构体在 runtime 中的定义开头就有注释:The offsets of sp, pc, and g are known to (hard-coded in) libmach。也就是说,这类"用名字代替偏移量"的写法由链接器换算成实际偏移,对阅读者而言非常直观。

用一张流程图总结:从 g0 到 main goroutine

从 g0 切换到 main goroutine 的流程

整个首次切换可以概括为五个步骤:

  1. 保存 g0 的调度信息:mstart1 中调用 gosave,把 g0 的 sp/pc 等现场写入 g0.sched;
  2. 找到 main goroutine:schedule 从 p0 本地运行队列中取出之前 runqput 进去的 main goroutine;
  3. 从 g0 栈切换到 gp 栈:execute 修改 g 状态、绑定 m 与 gp;
  4. 跳转到 gp.sched.pc:gogo 恢复寄存器与栈,改写 tls[0] 指向 gp;
  5. 执行 runtime.main:CPU 跳转到 runtime.main,最终进入用户 main 函数。

从这一刻起,Go 程序才算真正"活"了起来——而这仅仅是一轮调度循环的开始。main goroutine 执行完毕后会走 goexit 清理路径,普通 goroutine 则会通过 mcall 切回 g0 栈,再次进入 schedule,开启新的一轮调度,形成 schedule 循环如何运转 所描述的完整闭环:

schedule() -> execute() -> gogo() -> goroutine 任务 -> goexit() -> goexit1() -> mcall() -> goexit0() -> schedule()

延伸阅读

本文涉及到的完整调度链路,可继续阅读本仓库调度器专题的以下篇章:

登录后查看全文
go-questions