Go并发调度进阶

1. GMP主要结构

元旦结束了，该收收心工作了。今天主要是为大家带来GMP主要结构和调度器结构，欢迎大家点赞关注和转发哈。

1. G 的结构

G 既然是 Goroutine，必然需要定义自身的执行栈：

type g struct {
 stack struct {
  lo uintptr
  hi uintptr
 }        // 栈内存：[stack.lo, stack.hi)
 stackguard0 uintptr
 stackguard1 uintptr

 _panic       *_panic
 _defer       *_defer
 m            *m    // 当前的 m
 sched        gobuf
 stktopsp     uintptr  // 期望 sp 位于栈顶，用于回溯检查
 param        unsafe.Pointer // wakeup 唤醒时候传递的参数
 atomicstatus uint32
 goid         int64
 preempt      bool        // 抢占信号，stackguard0 = stackpreempt 的副本
 timer        *timer         // 为 time.Sleep 缓存的计时器

 ...
}

除了执行栈之外，还有很多与调试和 profiling 相关的字段。一个 G 没有什么黑魔法，无非是将需要执行的函数参数进行了拷贝，保存了要执行的函数体的入口地址，用于执行。

2. M 的结构

type m struct {
 g0          *g   // 用于执行调度指令的 Goroutine
 gsignal     *g   // 处理 signal 的 g
 tls         [6]uintptr // 线程本地存储
 curg        *g   // 当前运行的用户 Goroutine
 p           puintptr // 执行 go 代码时持有的 p (如果没有执行则为 nil)
 spinning    bool  // m 当前没有运行 task 且正处于寻找 task 的活跃状态
 cgoCallers  *cgoCallers // cgo 调用崩溃的 cgo 回溯
 alllink     *m   // 在 allm 上
 mcache      *mcache

 ...
}

M 是 OS 线程的实体。我们介绍几个比较重要的字段，包括：

持有用于执行调度器的 g0，goroutine切换需要用到它。
持有用于信号处理的 gsignal
持有线程本地存储 tls
持有当前正在运行的 curg
持有运行 Goroutine 时需要的本地资源 p
表示自身的自旋和非自旋状态 spining
管理在它身上执行的 cgo 调用
将自己与其他的 M 进行串联
持有当前线程上进行内存分配的本地缓存 mcache，内存分配使用。

还有其他五十多个字段，包括关于M的一些调度统计、调试信息等，因为不太重要就没有给大家罗列出来。

3. P 的结构

type p struct {
 id           int32
 status       uint32 // p 的状态 pidle/prunning/...
 link         puintptr
 m            muintptr   // 反向链接到关联的 m （nil 则表示 idle）
 mcache       *mcache
 pcache       pageCache
 deferpool    [5][]*_defer // 不同大小的可用的 defer 结构池
 deferpoolbuf [5][32]*_defer
 runqhead     uint32 // 可运行的 Goroutine 队列，可无锁访问 这是队列头
 runqtail     uint32 //队列尾
 runq         [256]guintptr //使用数组实现的循环队列
 runnext      guintptr
 timersLock   mutex
 timers       []*timer
 preempt      bool
 ...
}

P 只是处理器的抽象，而非处理器本身，大家一定要记住这句话，它仅仅是处理器的抽象，它存在的意义在于实现工作窃取（work stealing）算法。简单来说，每个 P 持有一个本地队列，这个本地队列中存储的就是未来要被调度的 G。

在没有 P 的情况下，所有的 G 只能放在一个全局的队列中。当 M 执行完 G 之后想从全局队列中获取一个G的时候，必须将队列锁住从而取G。

当引入了 P 之后，P 持有 G 的本地队列，而持有 P 的 M 执行完 G 后在 P 本地队列中没有发现其他 G 可以执行时，虽然仍然会先检查全局队列、网络轮询器，但这时增加了一个从其他 P 的队列偷取（steal）一个 G 来执行的过程。优先级为本地 > 全局 > 网络轮询器 > 偷取。

我们举个例子你就知道了：银行柜台有三个窗口，每个窗口都有顾客在排队(本地队列)，但是有一个窗口由于处理速度很快一下子就没有人了(本地队列为空)，那么这个时候没有在排队的顾客(全局队列)会立刻跑到该窗口，当这个窗口彻底没有人时(全局队列为空)，排在其他两个窗口的人迅速跑到这个窗口，即所谓的偷取。

4. GMP调用关系

M 会从与它绑定的 P 的本地队列获取可运行的 G，也会从网络轮询器里获取可运行的 G，还会从其他 P 偷 G。

5. 调度器sched结构

type schedt struct {
 lock mutex

 pidle      puintptr // 空闲 p 链表
 npidle     uint32 // 空闲 p 数量
 nmspinning uint32 // 自旋状态的 M 的数量
 runq       gQueue // 全局 runnable G 队列
 runqsize   int32
 gFree struct {  // 有效 dead G 的全局缓存.
  lock    mutex
  stack   gList // 包含栈的 Gs
  noStack gList // 没有栈的 Gs
  n       int32
 }
 sudoglock  mutex // sudog 结构的集中缓存
 sudogcache *sudog
 deferlock  mutex // 不同大小的有效的 defer 结构的池
 deferpool  [5]*_defer
 
 ...
}

调度器初始化步骤：

// runtime/proc.go
func schedinit() {
 _g_ := getg() //当前main的G
 (...)

 // M 初始化
 mcommoninit(_g_.m)
 (...)

 // P 初始化
 if procresize(procs) != nil {
  throw("unknown runnable goroutine during bootstrap")
 }
 (...)
}

GMP彼此的初始化顺序遵循：mcommoninit、procresize、newproc，他们分别负责初始化 M 资源池（allm）、P 资源池（allp）、G 的运行现场（g.sched）以及调度队列（p.runq）。

6. 小结

本小节主要是讲解GMP主要结构以及调度器结构，下篇主要讲解GMP如何初始化的，相信大家在看完这篇GMP基础之后，再结合下篇文章GMP的初始化，那么就会对GMP有一个更加完美的认识，同时你也不用非得报班花6000多的大洋去学习，那些冤枉钱只会让你越来越贫穷，越来越觉得钱花了，工作没有找到，悲矣。