goroutine 如何退出
上一讲说到调度器将 main goroutine 推上舞台,为它铺好了道路,开始执行 runtime.main 函数。这一讲,我们探索 main goroutine 以及普通 goroutine 从执行到退出的整个过程。
1
// The main goroutine.
2
func main() {
3
// g = main goroutine,不再是 g0 了
4
g := getg()
5
6
// ……………………
7
8
if sys.PtrSize == 8 {
9
maxstacksize = 1000000000
10
} else {
11
maxstacksize = 250000000
12
}
13
14
// Allow newproc to start new Ms.
15
mainStarted = true
16
17
systemstack(func() {
18
// 创建监控线程,该线程独立于调度器,不需要跟 p 关联即可运行
19
newm(sysmon, nil)
20
})
21
22
lockOSThread()
23
24
if g.m != &m0 {
25
throw("runtime.main not on m0")
26
}
27
28
// 调用 runtime 包的初始化函数,由编译器实现
29
runtime_init() // must be before defer
30
if nanotime() == 0 {
31
throw("nanotime returning zero")
32
}
33
34
// Defer unlock so that runtime.Goexit during init does the unlock too.
35
needUnlock := true
36
defer func() {
37
if needUnlock {
38
unlockOSThread()
39
}
40
}()
41
42
// Record when the world started. Must be after runtime_init
43
// because nanotime on some platforms depends on startNano.
44
runtimeInitTime = nanotime()
45
46
// 开启垃圾回收器
47
gcenable()
48
49
main_init_done = make(chan bool)
50
51
// ……………………
52
53
// main 包的初始化,递归的调用我们 import 进来的包的初始化函数
54
fn := main_init
55
fn()
56
close(main_init_done)
57
58
needUnlock = false
59
unlockOSThread()
60
61
// ……………………
62
63
// 调用 main.main 函数
64
fn = main_main
65
fn()
66
if raceenabled {
67
racefini()
68
}
69
70
// ……………………
71
72
// 进入系统调用,退出进程,可以看出 main goroutine 并未返回,而是直接进入系统调用退出进程了
73
exit(0)
74
// 保护性代码,如果 exit 意外返回,下面的代码会让该进程 crash 死掉
75
for {
76
var x *int32
77
*x = 0
78
}
79
}
Copied!
main 函数执行流程如下图:
runtime.main 启动流程
从流程图可知,main goroutine 执行完之后就直接调用 exit(0) 退出了,这会导致整个进程退出,太粗暴了。
不过,main goroutine 实际上就是代表用户的 main 函数,它都执行完了,肯定是用户的任务都执行完了,直接退出就可以了,就算有其他的 goroutine 没执行完,同样会直接退出。
1
package main
2
3
import "fmt"
4
5
func main() {
6
go func() {fmt.Println("hello qcrao.com")}()
7
}
Copied!
在这个例子中,main gorutine 退出时,还来不及执行 go 出去 的函数,整个进程就直接退出了,打印语句不会执行。因此,main goroutine 不会等待其他 goroutine 执行完再退出,知道这个有时能解释一些现象,比如上面那个例子。
这时,心中可能会跳出疑问,我们在新创建 goroutine 的时候,不是整出了个“偷天换日”,风风火火地设置了 goroutine 退出时应该跳到 runtime.goexit 函数吗,怎么这会不用了,闲得慌?
回顾一下上一讲的内容,跳转到 main 函数的两行代码:
1
// 把 sched.pc 值放入 BX 寄存器
2
MOVQ gobuf_pc(BX), BX
3
// JMP 把 BX 寄存器的包含的地址值放入 CPU 的 IP 寄存器,于是,CPU 跳转到该地址继续执行指令
4
JMP BX
Copied!
直接使用了一个跳转,并没有使用 CALL 指令,而 runtime.main 函数中确实也没有 RET 返回的指令。所以,main goroutine 执行完后,直接调用 exit(0) 退出整个进程。
那之前整地“偷天换日”还有用吗?有的!这是针对非 main goroutine 起作用。
参考资料【阿波张 非 goroutine 的退出】中用调试工具验证了非 main goroutine 的退出,感兴趣的可以去跟着实践一遍。
我们继续探索非 main goroutine (后文我们就称 gp 好了)的退出流程。
gp 执行完后,RET 指令弹出 goexit 函数地址(实际上是 funcPC(goexit)+1),CPU 跳转到 goexit 的第二条指令继续执行:
1
// src/runtime/asm_amd64.s
2
3
// The top-most function running on a goroutine
4
// returns to goexit+PCQuantum.
5
TEXT runtime·goexit(SB),NOSPLIT,$0-0
6
BYTE $0x90 // NOP
7
CALL runtime·goexit1(SB) // does not return
8
// traceback from goexit1 must hit code range of goexit
9
BYTE $0x90 // NOP
Copied!
直接调用 runtime·goexit1
1
// src/runtime/proc.go
2
// Finishes execution of the current goroutine.
3
func goexit1() {
4
// ……………………
5
mcall(goexit0)
6
}
Copied!
调用 mcall 函数:
1
// 切换到 g0 栈,执行 fn(g)
2
// Fn 不能返回
3
TEXT runtime·mcall(SB), NOSPLIT, $0-8
4
// 取出参数的值放入 DI 寄存器,它是 funcval 对象的指针,此场景中 fn.fn 是 goexit0 的地址
5
MOVQ fn+0(FP), DI
6
7
get_tls(CX)
8
// AX = g
9
MOVQ g(CX), AX // save state in g->sched
10
// mcall 返回地址放入 BX
11
MOVQ 0(SP), BX // caller's PC
12
// g.sched.pc = BX,保存 g 的 PC
13
MOVQ BX, (g_sched+gobuf_pc)(AX)
14
LEAQ fn+0(FP), BX // caller's SP
15
// 保存 g 的 SP
16
MOVQ BX, (g_sched+gobuf_sp)(AX)
17
MOVQ AX, (g_sched+gobuf_g)(AX)
18
MOVQ BP, (g_sched+gobuf_bp)(AX)
19
20
// switch to m->g0 & its stack, call fn
21
MOVQ g(CX), BX
22
MOVQ g_m(BX), BX
23
// SI = g0
24
MOVQ m_g0(BX), SI
25
CMPQ SI, AX // if g == m->g0 call badmcall
26
JNE 3(PC)
27
MOVQ $runtime·badmcall(SB), AX
28
JMP AX
29
// 把 g0 的地址设置到线程本地存储中
30
MOVQ SI, g(CX) // g = m->g0
31
// 从 g 的栈切换到了 g0 的栈D
32
MOVQ (g_sched+gobuf_sp)(SI), SP // sp = m->g0->sched.sp
33
// AX = g,参数入栈
34
PUSHQ AX
35
MOVQ DI, DX
36
// DI 是结构体 funcval 实例对象的指针,它的第一个成员才是 goexit0 的地址
37
// 读取第一个成员到 DI 寄存器
38
MOVQ 0(DI), DI
39
// 调用 goexit0(g)
40
CALL DI
41
POPQ AX
42
MOVQ $runtime·badmcall2(SB), AX
43
JMP AX
44
RET
Copied!
函数参数是:
1
type funcval struct {
2
fn uintptr
3
// variable-size, fn-specific data here
4
}
Copied!
字段 fn 就表示 goexit0 函数的地址。
L5 将函数参数保存到 DI 寄存器,这里 fn.fn 就是 goexit0 的地址。
L7 将 tls 保存到 CX 寄存器,L9 将 当前线程指向的 goroutine (非 main goroutine,称为 gp)保存到 AX 寄存器,L11 将调用者(调用 mcall 函数)的栈顶,这里就是 mcall 完成后的返回地址,存入 BX 寄存器。
L13 将 mcall 的返回地址保存到 gp 的 g.sched.pc 字段,L14 将 gp 的栈顶,也就是 SP 保存到 BX 寄存器,L16 将 SP 保存到 gp 的 g.sched.sp 字段,L17 将 g 保存到 gp 的 g.sched.g 字段,L18 将 BP 保存 到 gp 的 g.sched.bp 字段。这一段主要是保存 gp 的调度信息。
L21 将当前指向的 g 保存到 BX 寄存器,L22 将 g.m 字段保存到 BX 寄存器,L23 将 g.m.g0 字段保存到 SI,g.m.g0 就是当前工作线程的 g0。
现在,SI = g0, AX = gp,L25 判断 gp 是否是 g0,如果 gp == g0 说明有问题,执行 runtime·badmcall。正常情况下,PC 值加 3,跳过下面的两条指令,直接到达 L30。
L30 将 g0 的地址设置到线程本地存储中,L32 将 g0.SP 设置到 CPU 的 SP 寄存器,这也就意味着我们从 gp 栈切换到了 g0 的栈,要变天了!
L34 将参数 gp 入栈,为调用 goexit0 构造参数。L35 将 DI 寄存器的内容设置到 DX 寄存器,DI 是结构体 funcval 实例对象的指针,它的第一个成员才是 goexit0 的地址。L36 读取 DI 第一成员,也就是 goexit0 函数的地址。
L40 调用 goexit0 函数,这已经是在 g0 栈上执行了,函数参数就是 gp。
到这里,就会去执行 goexit0 函数,注意,这里永远都不会返回。所以,在 CALL 指令后面,如果返回了,又会去调用 runtime.badmcall2 函数去处理意外情况。
来继续看 goexit0:
1
// goexit continuation on g0.
2
// 在 g0 上执行
3
func goexit0(gp *g) {
4
// g0
5
_g_ := getg()
6
7
casgstatus(gp, _Grunning, _Gdead)
8
if isSystemGoroutine(gp) {
9
atomic.Xadd(&sched.ngsys, -1)
10
}
11
12
// 清空 gp 的一些字段
13
gp.m = nil
14
gp.lockedm = nil
15
_g_.m.lockedg = nil
16
gp.paniconfault = false
17
gp._defer = nil // should be true already but just in case.
18
gp._panic = nil // non-nil for Goexit during panic. points at stack-allocated data.
19
gp.writebuf = nil
20
gp.waitreason = ""
21
gp.param = nil
22
gp.labels = nil
23
gp.timer = nil
24
25
// Note that gp's stack scan is now "valid" because it has no
26
// stack.
27
gp.gcscanvalid = true
28
// 解除 g 与 m 的关系
29
dropg()
30
31
if _g_.m.locked&^_LockExternal != 0 {
32
print("invalid m->locked = ", _g_.m.locked, "\n")
33
throw("internal lockOSThread error")
34
}
35
_g_.m.locked = 0
36
// 将 g 放入 free 队列缓存起来
37
gfput(_g_.m.p.ptr(), gp)
38
schedule()
39
}
Copied!
它主要完成最后的清理工作:
  1. 1.
    把 g 的状态从 _Grunning 更新为 _Gdead
  2. 2.
    清空 g 的一些字段;
  3. 3.
    调用 dropg 函数解除 g 和 m 之间的关系,其实就是设置 g->m = nil, m->currg = nil;
  4. 4.
    把 g 放入 p 的 freeg 队列缓存起来供下次创建 g 时快速获取而不用从内存分配。freeg 就是 g 的一个对象池;
  5. 5.
    调用 schedule 函数再次进行调度。
到这里,gp 就完成了它的历史使命,功成身退,进入了 goroutine 缓存池,待下次有任务再重新启用。
而工作线程,又继续调用 schedule 函数进行新一轮的调度,整个过程形成了一个循环。
总结一下,main goroutine 和普通 goroutine 的退出过程:
对于 main goroutine,在执行完用户定义的 main 函数的所有代码后,直接调用 exit(0) 退出整个进程,非常霸道。
对于普通 goroutine 则没这么“舒服”,需要经历一系列的过程。先是跳转到提前设置好的 goexit 函数的第二条指令,然后调用 runtime.goexit1,接着调用 mcall(goexit0),而 mcall 函数会切换到 g0 栈,运行 goexit0 函数,清理 goroutine 的一些字段,并将其添加到 goroutine 缓存池里,然后进入 schedule 调度循环。到这里,普通 goroutine 才算完成使命。

参考资料

【阿波张 非 main goroutine 的退出及调度循环】https://mp.weixin.qq.com/s/XttP9q7-PO7VXhskaBzGqA
Copy link
Contents
参考资料