goroutine调度源码

参考解析

题目来源： 陌陌

答案:

G、P、M 是 Go 调度器的三个核心组件，各司其职。在它们精密地配合下，Go 调度器得以高效运转，这也是Go天然支持高并发的内在动力。今天这篇文章我们来深入理解 GPM 模型。

先看 G，取 goroutine 的首字母，主要保存 goroutine 的一些状态信息以及 CPU 的一些寄存器的值，例如 IP 寄存器，以便在轮到本 goroutine 执行时，CPU 知道要从哪一条指令处开始执行。
runtime.g 的源码如下：

  1. type g struct {
  3.     // goroutine 使用的栈
  4.     stack stack
  5.     // offset known to runtime/cgo
  6.     // 用于栈的扩张和收缩检查，抢占标志
  7.     stackguard0 uintptr
  8.     // offset known to liblink
  10.     stackguard1 uintptr
  11.     // offset known to liblink
  12.     _panic *_panic
  13.     // innermost panic - offset known to liblink
  14.     _defer *_defer
  16.     // 当前与 g 绑定的 m
  17.     m *m
  18.     // current m; offset known to arm liblink
  19.     // goroutine 的运行现场
  20.     sched gobuf
  22.     syscallsp uintptr
  23.     // if status==Gsyscall, syscallsp = sched.sp to use during gc
  25.     syscallpc uintptr
  26.     // if status==Gsyscall, syscallpc = sched.pc to use during gc
  28.     stktopsp uintptr
  29.     // expected sp at top of stack, to check in traceback
  31.     // wakeup 时传入的参数
  32.     param unsafe.Pointer
  34.     // passed parameter on wakeup
  36.     atomicstatus uint32
  38.     stackLock uint32
  39.     // sigprof/scang lock;
  40.     goid int64
  42.     // g 被阻塞之后的近似时间
  43.     waitsince int64
  44.     // approx time when the g become blocked
  46.     // g 被阻塞的原因
  47.     waitreason string
  49.     // 指向全局队列里下一个 g
  50.     schedlink guintptr
  52.     // 抢占调度标志。这个为 true 时，stackguard0 等于 stackpreempt
  53.     preempt bool
  55.     // preemption signal, duplicates stackguard0 = stackpreempt
  56.     paniconfault bool
  58.     // panic (instead of crash) on unexpected fault address
  59.     preemptscan bool
  61.     // preempted g does scan for gc
  62.     gcscandone bool
  64.     // g has scanned stack; protected by _Gscan bit in status
  65.     gcscanvalid bool
  66.     // false at start of gc cycle, true if G has not run since last scan;
  67.     throwsplit bool
  69.     // must not split stack
  70.     raceignore int8
  71.     // ignore race detection events
  72.     sysblocktraced bool
  74.     // StartTrace has emitted EvGoInSyscall about this goroutine
  76.     // syscall 返回之后的 cputicks，用来做 tracing
  78.     sysexitticks int64
  79.     // cputicks when syscall has returned (for tracing)
  81.     traceseq uint64
  82.     // trace event sequencer
  83.     tracelastp puintptr
  84.     // last P emitted an event for this goroutine
  85.     // 如果调用了 LockOsThread，那么这个 g 会绑定到某个 m 上
  86.     lockedm *m
  87.     sig uint32
  88.     writebuf []byte
  90.     sigcode0 uintptr
  92.     sigcode1 uintptr
  94.     sigpc uintptr
  95.     // 创建该 goroutine 的语句的指令地址
  97.     gopc uintptr
  98.     // pc of go statement that created this goroutine
  99.     // goroutine 函数的指令地址
  101.     startpc uintptr
  102.     // pc of goroutine function
  104.     racectx uintptr
  106.     waiting *sudog
  107.     // sudog structures this g is waiting on (that have a valid elem ptr); in lock order
  109.     cgoCtxt []uintptr
  110.     // cgo traceback context
  112.     labels unsafe.Pointer
  113.     // profiler labels
  115.     // time.Sleep 缓存的定时器
  116.     timer *timer
  117.     // cached timer for time.Sleep
  119.     gcAssistBytes int64
  120. }

再来看 M，取 machine 的首字母，它代表一个工作线程，或者说系统线程。G 需要调度到 M 上才能运行，M 是真正工作的人。结构体 m 就是我们常说的 M，它保存了 M 自身使用的栈信息、当前正在 M 上执行的 G 信息、与之绑定的 P 信息……

当 M 没有工作可做的时候，在它休眠前，会“自旋”地来找工作：检查全局队列，查看 network poller，试图执行 gc 任务，或者“偷”工作。

结构体 m 的源码如下：

  1. type m struct {
  2.     // 记录工作线程（也就是内核线程）使用的栈信息。在执行调度代码时需要使用
  3.     // 执行用户 goroutine 代码时，使用用户 goroutine 自己的栈，因此调度时会发生栈的切换
  4.     g0 *g
  5.     // goroutine with scheduling stack/
  6.     morebuf gobuf
  7.     // gobuf arg to morestack
  9.     divmod uint32
  10.     // div/mod denominator for arm - known to liblink
  11.     // Fields not known to debuggers.
  13.     procid uint64
  14.     // for debuggers, but offset not hard-coded
  16.     gsignal *g
  17.     // signal-handling g
  19.     sigmask sigset
  20.     // storage for saved signal mask
  21.     // 通过 tls 结构体实现 m 与工作线程的绑定
  22.     // 这里是线程本地存储
  23.     tls [6]uintptr
  24.     // thread-local storage (for x86 extern register)
  25.     mstartfn func()
  27.     // 指向正在运行的 gorutine 对象
  28.     curg *g
  29.     // current running goroutine
  30.     caughtsig guintptr
  31.     // goroutine running during fatal signal
  33.     // 当前工作线程绑定的 p
  34.     p puintptr
  35.     // attached p for executing go code (nil if not executing go code)
  36.     nextp puintptr
  38.     id int32
  40.     mallocing int32
  42.     throwing int32
  44.     // 该字段不等于空字符串的话，要保持 curg 始终在这个 m 上运行
  45.     preemptoff string
  46.     // if != "", keep curg running on this m
  47.     locks int32
  49.     softfloat int32
  51.     dying int32
  53.     profilehz int32
  55.     helpgc int32
  57.     // 为 true 时表示当前 m 处于自旋状态，正在从其他线程偷工作
  58.     spinning bool
  60.     // m is out of work and is actively looking for work
  61.     // m 正阻塞在 note 上
  62.     blocked bool
  64.     // m is blocked on a note
  65.     // m 正在执行 write barrier
  66.     inwb bool
  68.     // m is executing a write barrier
  69.     newSigstack bool
  71.     // minit on C thread called sigaltstack
  72.     printlock int8
  74.     // 正在执行 cgo 调用
  75.     incgo bool
  77.     // m is executing a cgo call
  78.     fastrand uint32
  80.     // cgo 调用总计数
  81.     ncgocall uint64
  82.     // number of cgo calls in total
  84.     ncgo int32
  85.     // number of cgo calls currently in progress
  87.     cgoCallersUse uint32
  88.     // if non-zero, cgoCallers in use temporarily
  90.     cgoCallers *cgoCallers
  91.     // cgo traceback if crashing in cgo call
  93.     // 没有 goroutine 需要运行时，工作线程睡眠在这个 park 成员上，
  95.     // 其它线程通过这个 park 唤醒该工作线程
  96.     park note
  98.     // 记录所有工作线程的链表
  99.     alllink *m
  100.     // on allm
  102.     schedlink muintptr
  104.     mcache *mcache
  106.     lockedg *g
  108.     createstack [32]uintptr
  109.     // stack that created this thread.
  111.     freglo [16]uint32
  112.     // d[i] lsb and f[i]
  114.     freghi [16]uint32
  115.     // d[i] msb and f[i+16]
  117.     fflag uint32
  118.     // floating point compare flags
  120.     locked uint32
  121.     // tracking for lockosthread
  123.     // 正在等待锁的下一个 m
  125.     nextwaitm uintptr
  126.     // next m waiting for lock
  128.     needextram bool
  130.     traceback uint8
  132.     waitunlockf unsafe.Pointer
  133.     // todo go func(*g, unsafe.pointer) bool
  135.     waitlock unsafe.Pointer
  137.     waittraceev byte
  139.     waittraceskip int
  141.     startingtrace bool
  143.     syscalltick uint32
  145.     // 工作线程 id
  146.     thread uintptr
  147.     // thread handle
  149.     // these are here because they are too large to be on the stack
  151.     // of low-level NOSPLIT functions.
  153.     libcall libcall
  155.     libcallpc uintptr
  156.     // for cpu profiler
  158.     libcallsp uintptr
  160.     libcallg guintptr
  162.     syscall libcall
  163.     // stores syscall parameters on windows
  165.     mOS
  166. }

再来看 P，取 processor 的首字母，为 M 的执行提供“上下文”，保存 M 执行 G 时的一些资源，例如本地可运行 G 队列，memeory cache 等。

一个 M 只有绑定 P 才能执行 goroutine，当 M 被阻塞时，整个 P 会被传递给其他 M ，或者说整个 P 被接管。

// p 保存 go 运行时所必须的资源

  1. type p struct {
  2.     lock mutex
  3.     // 在 allp 中的索引
  4.     id int32
  6.     status uint32
  7.     // one of pidle/prunning/...
  9.     link puintptr
  11.     // 每次调用 schedule 时会加一
  12.     schedtick uint32
  14.     // 每次系统调用时加一
  15.     syscalltick uint32
  17.     // 用于 sysmon 线程记录被监控 p 的系统调用时间和运行时间
  18.     sysmontick sysmontick
  19.     // last tick observed by sysmon
  21.     // 指向绑定的 m，如果 p 是 idle 的话，那这个指针是 nil
  22.     m muintptr
  23.     // back-link to associated m (nil if idle)
  24.     mcache  *mcache
  25.     racectx uintptr
  27.     deferpool [5][]*_defer
  28.     // pool of available defer structs of different sizes (see panic.go)
  29.     deferpoolbuf [5][32]*_defer
  31.     // Cache of goroutine ids, amortizes accesses to runtime·sched.goidgen.
  32.     goidcache    uint64
  33.     goidcacheend uint64
  35.     // Queue of runnable goroutines. Accessed without lock.
  36.     // 本地可运行的队列，不用通过锁即可访问
  37.     runqhead uint32
  38.     // 队列头
  39.     runqtail uint32
  40.     // 队列尾
  41.     // 使用数组实现的循环队列
  42.     runq [256]guintptr
  44.     // runnext 非空时，代表的是一个 runnable 状态的 G，
  45.     // 这个 G 被 当前 G 修改为 ready 状态，相比 runq 中的 G 有更高的优先级。
  46.     // 如果当前 G 还有剩余的可用时间，那么就应该运行这个 G
  47.     // 运行之后，该 G 会继承当前 G 的剩余时间
  48.     runnext guintptr
  50.     // Available G's (status == Gdead)
  51.     // 空闲的 g
  52.     gfree    *g
  53.     gfreecnt int32
  55.     sudogcache []*sudog
  56.     sudogbuf   [128]*sudog
  58.     tracebuf                   traceBufPtr
  59.     traceSwept, traceReclaimed uintptr
  60.     palloc                     persistentAlloc
  61.     // per-P to avoid mutex
  62.     // Per-P GC state
  63.     gcAssistTime int64
  64.     // Nanoseconds in assistAlloc
  66.     gcBgMarkWorker guintptr
  68.     gcMarkWorkerMode gcMarkWorkerMode
  70.     runSafePointFn uint32
  71.     // if 1, run sched.safePointFn at next safe point
  72.     pad [sys.CacheLineSize]byte
  73. }