当 Go 语言程序启动时,运行时会在第一个 Goroutine 中调用 [runtime.main](https://draveness.me/golang/tree/runtime.main) 启动主程序,该函数会在系统栈中创建新的线程:

  1. func main() {
  2. ...
  3. if GOARCH != "wasm" {
  4. systemstack(func() {
  5. newm(sysmon, nil)
  6. })
  7. }
  8. ...
  9. }

[runtime.newm](https://draveness.me/golang/tree/runtime.newm) 会创建一个存储待执行函数和处理器的新结构体 [runtime.m](https://draveness.me/golang/tree/runtime.m)。运行时执行系统监控不需要处理器,系统监控的 Goroutine 会直接在创建的线程上运行:

  1. func newm(fn func(), _p_ *p) {
  2. mp := allocm(_p_, fn)
  3. mp.nextp.set(_p_)
  4. mp.sigmask = initSigmask
  5. ...
  6. newm1(mp)
  7. }

[runtime.newm1](https://draveness.me/golang/tree/runtime.newm1) 会调用特定平台的 [runtime.newsproc](https://draveness.me/golang/tree/runtime.newsproc) 通过系统调用 clone 创建一个新的线程并在新的线程中执行 [runtime.mstart](https://draveness.me/golang/tree/runtime.mstart)

  1. func newosproc(mp *m) {
  2. stk := unsafe.Pointer(mp.g0.stack.hi)
  3. var oset sigset
  4. sigprocmask(_SIG_SETMASK, &sigset_all, &oset)
  5. ret := clone(cloneFlags, stk, unsafe.Pointer(mp), unsafe.Pointer(mp.g0), unsafe.Pointer(funcPC(mstart)))
  6. sigprocmask(_SIG_SETMASK, &oset, nil)
  7. ...
  8. }

在新创建的线程中,我们会执行存储在 [runtime.m](https://draveness.me/golang/tree/runtime.m) 中的 [runtime.sysmon](https://draveness.me/golang/tree/runtime.sysmon) 启动系统监控:

  1. func sysmon() {
  2. sched.nmsys++
  3. checkdead()
  4. lasttrace := int64(0)
  5. idle := 0
  6. delay := uint32(0)
  7. for {
  8. if idle == 0 {
  9. delay = 20
  10. } else if idle > 50 {
  11. delay *= 2
  12. }
  13. if delay > 10*1000 {
  14. delay = 10 * 1000
  15. }
  16. usleep(delay)
  17. ...
  18. }
  19. }

当运行时刚刚调用上述函数时,会先通过 [runtime.checkdead](https://draveness.me/golang/tree/runtime.checkdead) 检查是否存在死锁,然后进入核心的监控循环;系统监控在每次循环开始时都会通过 usleep 挂起当前线程,该函数的参数是微秒,运行时会遵循以下的规则决定休眠时间:

  • 初始的休眠时间是 20μs;
  • 最长的休眠时间是 10ms;
  • 当系统监控在 50 个循环中都没有唤醒 Goroutine 时,休眠时间在每个循环都会倍增;

当程序趋于稳定之后,系统监控的触发时间就会稳定在 10ms。它除了会检查死锁之外,还会在循环中完成以下的工作:

  • 运行计时器 — 获取下一个需要被触发的计时器;
  • 轮询网络 — 获取需要处理的到期文件描述符;
  • 抢占处理器 — 抢占运行时间较长的或者处于系统调用的 Goroutine;
  • 垃圾回收 — 在满足条件时触发垃圾收集回收内存;

检查死锁

系统监控通过 [runtime.checkdead](https://draveness.me/golang/tree/runtime.checkdead) 检查运行时是否发生了死锁,我们可以将检查死锁的过程分成以下三个步骤:

  1. 检查是否存在正在运行的线程;
  2. 检查是否存在正在运行的 Goroutine;
  3. 检查处理器上是否存在计时器;

该函数首先会检查 Go 语言运行时中正在运行的线程数量,我们通过调度器中的多个字段计算该值的结果:

  1. func checkdead() {
  2. var run0 int32
  3. run := mcount() - sched.nmidle - sched.nmidlelocked - sched.nmsys
  4. if run > run0 {
  5. return
  6. }
  7. if run < 0 {
  8. print("runtime: checkdead: nmidle=", sched.nmidle, " nmidlelocked=", sched.nmidlelocked, " mcount=", mcount(), " nmsys=", sched.nmsys, "\n")
  9. throw("checkdead: inconsistent counts")
  10. }
  11. ...
  12. }
  1. [runtime.mcount](https://draveness.me/golang/tree/runtime.mcount) 根据下一个待创建的线程 id 和释放的线程数得到系统中存在的线程数;
  2. nmidle 是处于空闲状态的线程数量;
  3. nmidlelocked 是处于锁定状态的线程数量;
  4. nmsys 是处于系统调用的线程数量;

利用上述几个线程相关数据,我们可以得到正在运行的线程数,如果线程数量大于 0,说明当前程序不存在死锁;如果线程数小于 0,说明当前程序的状态不一致;如果线程数等于 0,我们需要进一步检查程序的运行状态:

  1. func checkdead() {
  2. ...
  3. grunning := 0
  4. for i := 0; i < len(allgs); i++ {
  5. gp := allgs[i]
  6. if isSystemGoroutine(gp, false) {
  7. continue
  8. }
  9. s := readgstatus(gp)
  10. switch s &^ _Gscan {
  11. case _Gwaiting, _Gpreempted:
  12. grunning++
  13. case _Grunnable, _Grunning, _Gsyscall:
  14. print("runtime: checkdead: find g ", gp.goid, " in status ", s, "\n")
  15. throw("checkdead: runnable g")
  16. }
  17. }
  18. unlock(&allglock)
  19. if grunning == 0 {
  20. throw("no goroutines (main called runtime.Goexit) - deadlock!")
  21. }
  22. ...
  23. }
  1. 当存在 Goroutine 处于 _Grunnable_Grunning_Gsyscall 状态时,意味着程序发生了死锁;
  2. 当所有的 Goroutine 都处于 _Gidle_Gdead_Gcopystack 状态时,意味着主程序调用了 [runtime.goexit](https://draveness.me/golang/tree/runtime.goexit)

当运行时存在等待的 Goroutine 并且不存在正在运行的 Goroutine 时,我们会检查处理器中存在的计时器

  1. func checkdead() {
  2. ...
  3. for _, _p_ := range allp {
  4. if len(_p_.timers) > 0 {
  5. return
  6. }
  7. }
  8. throw("all goroutines are asleep - deadlock!")
  9. }

如果处理器中存在等待的计时器,那么所有的 Goroutine 陷入休眠状态是合理的,不过如果不存在等待的计时器,运行时会直接报错并退出程序。

运行计时器

在系统监控的循环中,我们通过 runtime.nanotimeruntime.timeSleepUntil 获取当前时间和计时器下一次需要唤醒的时间;当前调度器需要执行垃圾回收或者所有处理器都处于闲置状态时,如果没有需要触发的计时器,那么系统监控可以暂时陷入休眠:

  1. func sysmon() {
  2. ...
  3. for {
  4. ...
  5. now := nanotime()
  6. next, _ := timeSleepUntil()
  7. if debug.schedtrace <= 0 && (sched.gcwaiting != 0 || atomic.Load(&sched.npidle) == uint32(gomaxprocs)) {
  8. lock(&sched.lock)
  9. if atomic.Load(&sched.gcwaiting) != 0 || atomic.Load(&sched.npidle) == uint32(gomaxprocs) {
  10. if next > now {
  11. atomic.Store(&sched.sysmonwait, 1)
  12. unlock(&sched.lock)
  13. sleep := forcegcperiod / 2
  14. if next-now < sleep {
  15. sleep = next - now
  16. }
  17. ...
  18. notetsleep(&sched.sysmonnote, sleep)
  19. ...
  20. now = nanotime()
  21. next, _ = timeSleepUntil()
  22. lock(&sched.lock)
  23. atomic.Store(&sched.sysmonwait, 0)
  24. noteclear(&sched.sysmonnote)
  25. }
  26. idle = 0
  27. delay = 20
  28. }
  29. unlock(&sched.lock)
  30. }
  31. ...
  32. if next < now {
  33. startm(nil, false)
  34. }
  35. }
  36. }

休眠的时间会依据强制 GC 的周期 forcegcperiod 和计时器下次触发的时间确定,runtime.notesleep 会使用信号量同步系统监控即将进入休眠的状态。当系统监控被唤醒之后,我们会重新计算当前时间和下一个计时器需要触发的时间、调用 runtime.noteclear 通知系统监控被唤醒并重置休眠的间隔。

如果在这之后,我们发现下一个计时器需要触发的时间小于当前时间,这也说明所有的线程可能正在忙于运行 Goroutine,系统监控会启动新的线程来触发计时器,避免计时器的到期时间有较大的偏差。

轮询网络

如果上一次轮询网络已经过去了 10ms,那么系统监控还会在循环中轮询网络,检查是否有待执行的文件描述符:

  1. func sysmon() {
  2. ...
  3. for {
  4. ...
  5. lastpoll := int64(atomic.Load64(&sched.lastpoll))
  6. if netpollinited() && lastpoll != 0 && lastpoll+10*1000*1000 < now {
  7. atomic.Cas64(&sched.lastpoll, uint64(lastpoll), uint64(now))
  8. list := netpoll(0)
  9. if !list.empty() {
  10. incidlelocked(-1)
  11. injectglist(&list)
  12. incidlelocked(1)
  13. }
  14. }
  15. ...
  16. }
  17. }

上述函数会非阻塞地调用 [runtime.netpoll](https://draveness.me/golang/tree/runtime.netpoll) 检查待执行的文件描述符并通过 [runtime.injectglist](https://draveness.me/golang/tree/runtime.injectglist) 将所有处于就绪状态的 Goroutine 加入全局运行队列中:

  1. func injectglist(glist *gList) {
  2. if glist.empty() {
  3. return
  4. }
  5. lock(&sched.lock)
  6. var n int
  7. for n = 0; !glist.empty(); n++ {
  8. gp := glist.pop()
  9. casgstatus(gp, _Gwaiting, _Grunnable)
  10. globrunqput(gp)
  11. }
  12. unlock(&sched.lock)
  13. for ; n != 0 && sched.npidle != 0; n-- {
  14. startm(nil, false)
  15. }
  16. *glist = gList{}
  17. }

该函数会将所有 Goroutine 的状态从 _Gwaiting 切换至 _Grunnable 并加入全局运行队列等待运行,如果当前程序中存在空闲的处理器,会通过 [runtime.startm](https://draveness.me/golang/tree/runtime.startm) 启动线程来执行这些任务。

抢占处理器

系统监控会在循环中调用 runtime.retake 抢占处于运行或者系统调用中的处理器,该函数会遍历运行时的全局处理器,每个处理器都存储了一个 runtime.sysmontick

  1. type sysmontick struct {
  2. schedtick uint32
  3. schedwhen int64
  4. syscalltick uint32
  5. syscallwhen int64
  6. }

该结构体中的四个字段分别存储了处理器的调度次数、处理器上次调度时间、系统调用的次数以及系统调用的时间。runtime.retake 的循环包含了两种不同的抢占逻辑:

  1. func retake(now int64) uint32 {
  2. n := 0
  3. for i := 0; i < len(allp); i++ {
  4. _p_ := allp[i]
  5. pd := &_p_.sysmontick
  6. s := _p_.status
  7. if s == _Prunning || s == _Psyscall {
  8. t := int64(_p_.schedtick)
  9. if pd.schedwhen+forcePreemptNS <= now {
  10. preemptone(_p_)
  11. }
  12. }
  13. if s == _Psyscall {
  14. if runqempty(_p_) && atomic.Load(&sched.nmspinning)+atomic.Load(&sched.npidle) > 0 && pd.syscallwhen+10*1000*1000 > now {
  15. continue
  16. }
  17. if atomic.Cas(&_p_.status, s, _Pidle) {
  18. n++
  19. _p_.syscalltick++
  20. handoffp(_p_)
  21. }
  22. }
  23. }
  24. return uint32(n)
  25. }
  1. 当处理器处于 _Prunning 或者 _Psyscall 状态时,如果上一次触发调度的时间已经过去了 10ms,我们会通过 [runtime.preemptone](https://draveness.me/golang/tree/runtime.preemptone) 抢占当前处理器;
  2. 当处理器处于_Psyscall状态时,在满足以下三种情况的任意一种下会调用[runtime.handoffp](https://draveness.me/golang/tree/runtime.handoffp)让出处理器的使用权:
  • p 的运行队列里面有等待运行的 goroutine
  • 没有无所事事的 p
  • 从上一次监控线程观察到 p 对应的 m 处于系统调用之中到现在已经超过 10 毫秒

系统监控通过在循环中抢占处理器来避免同一个 Goroutine 占用线程太长时间造成饥饿问题。

垃圾回收

在最后,系统监控还会决定是否需要触发强制垃圾回收,runtime.sysmon 会构建 runtime.gcTrigger 并调用 runtime.gcTrigger.test 方法判断是否需要触发垃圾回收:

  1. func sysmon() {
  2. ...
  3. for {
  4. ...
  5. if t := (gcTrigger{kind: gcTriggerTime, now: now}); t.test() && atomic.Load(&forcegc.idle) != 0 {
  6. lock(&forcegc.lock)
  7. forcegc.idle = 0
  8. var list gList
  9. list.push(forcegc.g)
  10. injectglist(&list)
  11. unlock(&forcegc.lock)
  12. }
  13. ...
  14. }
  15. }

如果需要触发垃圾回收,我们会将用于垃圾回收的 Goroutine 加入全局队列,让调度器选择合适的处理器去执行。