Go并发调度进阶
3. 循环调度
所有的GMP初始化工作都已经完成了，是时候启动运行时调度器了。我们已经知道，当所有准备工作都完成后， 最后一个开始执行的调用就是runtime.mstart了。
mstart主要功能：
- 确定执行栈的边界
- 启动
mstart1 - 设置退出线程标记osStack=true
- 调用mexit(osStack)退出线程
再来看下mstart1:
- 如果当前m并非m0，那么要求绑定p
- 开始调用
schedule()开始调度
所以我们可以看到调度循环schedule无法返回，因此最后一个mexit目前还不会被执行，因此当下所有的Go程序创建的线程都无法被释放。
1. M与P的绑定
M 与 P 的绑定过程(acquirep函数调用wirep绑定)只是简单的将 P 链表中的 P ，保存到 M 中的 P 指针上。绑定前，P 的状态一定是 _Pidle，绑定后 P 的状态一定为 _Prunning。
// 将 p 绑定到 m，p 和 m 互相引用 _g_.m.p.set(_p_) // *_g_.m.p = _p_ _p_.m.set(_g_.m) // *_p_.m = _g_.m // 修改 p 的状态 _p_.status = _Prunning
2. M的park和unpark
无论出于什么原因，当 M 需要被park时，可能会执行stopm调用。此调用会将 M 进行park，并阻塞到它被unpark时。这一过程就是工作线程的暂止(park)和复始(unpark)。
func stopm() { _g_ := getg() (...) // 将 m 放回到 空闲列表中，因为我们马上就要park了 lock(&sched.lock) mput(_g_.m) unlock(&sched.lock) // park当前的 M，在此阻塞，直到被唤醒 notesleep(&_g_.m.park) // 清除暂止的 note noteclear(&_g_.m.park) // 此时已经被unpark，说明有任务要执行 // 立即 acquire P acquirep(_g_.m.nextp.ptr()) _g_.m.nextp = 0 }
它的流程也非常简单，将 m 放回至空闲列表中，而后使用 note 注册一个暂止通知， 阻塞到它重新被复始。
3. 核心调度schedule
// 调度器的一轮：找到 runnable Goroutine 并进行执行且永不返回 func schedule() { _g_ := getg() (...) top: if sched.gcwaiting != 0 { // 如果需要 GC，不再进行调度 gcstopm() //park 还有就是偷取没有的时候也会park goto top } var gp *g (...) if gp == nil { // 说明不在 GC // 每调度 61 次，就检查一次全局队列，保证公平性 // 否则两个 Goroutine 可以通过互相 respawn 一直占领本地的 runqueue if _g_.m.p.ptr().schedtick%61 == 0 && sched.runqsize > 0 { lock(&sched.lock) // 从全局队列中偷 g gp = globrunqget(_g_.m.p.ptr(), 1) unlock(&sched.lock) } } if gp == nil { // 说明不在 gc // 两种情况： // 1. 普通取 // 2. 全局队列中偷不到的取 // 从本地队列中取 gp, inheritTime = runqget(_g_.m.p.ptr()) (...) } if gp == nil { // 如果偷都偷不到，则休眠，在此阻塞 gp, inheritTime = findrunnable() } // 这个时候一定取到 g 了 if _g_.m.spinning { // 如果 m 是自旋状态，则 // 1. 从自旋到非自旋 // 2. 在没有自旋状态的 m 的情况下，再多创建一个新的自旋状态的 m resetspinning() } if gp.lockedm != 0 { // 如果 g 需要 lock 到 m 上，则会将当前的 p // 给这个要 lock 的 g // 然后阻塞等待一个新的 p startlockedm(gp) goto top } // 开始执行 execute(gp, inheritTime) }
看下execute：
func execute(gp *g, inheritTime bool) { _g_ := getg() // 将 g 正式切换为 _Grunning 状态 casgstatus(gp, _Grunnable, _Grunning) // M 与 G 绑定开始执行 _g_.m.curg = gp gp.m = _g_.m // G终于开始执行了 gogo(&gp.sched) }
当开始执行 execute 后，g 会被切换到 _Grunning 状态，同时将 m 和 g 进行绑定。最终调用 gogo 开始执行。
gogo的执行是一段汇编代码，晦涩难懂哈。但是大致意思就是完成g0到gp的栈切换，然后开始执行runtime.main函数或者用户自定义的goroutine任务。
执行完成后，main goroutine 直接调用 eixt(0) 退出，普通 goroutine 则调用 goexit -> goexit1 -> mcall，完成普通 goroutine 退出后的清理工作，然后切换到 g0 栈，调用 goexit0 函数，将普通 goroutine 添加到缓存池中，再调用 schedule 函数进行新一轮的调度。
调度太复杂了，大致流程如下：
schedule() -> execute() -> gogo() -> goroutine 任务 -> goexit() -> goexit1() -> mcall() -> goexit0() -> schedule()
可以看出，一轮调度从调用 schedule 函数开始，经过一系列过程再次调用 schedule 函数来进行新一轮的调度，从一轮调度到新一轮调度的过程称之为一个调度循环。
这里说的调度循环是指某一个工作线程的调度循环，而同一个Go 程序中存在多个工作线程，每个工作线程都在进行着自己的调度循环。
4. 小结
由于调度核心太过于复杂，大家只需要了解大致流程或者思路就OK，没必要深入底层的细节。因为陷得越深你就越难理解一些细枝末节，我写到这里放弃了，不想深入研究下去了，只需要知道这个循环调度不是一个死循环就行了，而且调度链中的各个环节也应该大致了解下。好了今天就先到这里，欢迎大家关注转发分享哈。
