深入分析Go1.18 GMP调度器底层原理

// src/runtime/runtime2.go
type g struct {
  stack       stack       // 描述了当前 Goroutine 的栈内存范围 [stack.lo, stack.hi)
  stackguard0 uintptr     // 用于调度器抢占式调度
  _panic      *_panic     // 最内侧的 panic 结构体
  _defer      *_defer     // 最内侧的 defer 延迟函数结构体
  m           *m          // 当前 G 占用的线程，可能为空
  sched       gobuf       //  存储 G 的调度相关的数据
  atomicstatus uint32     // G 的状态
  goid         int64      //  G 的 ID
  waitreason   waitReason //当状态status==Gwaiting时等待的原因
  preempt       bool      // 抢占信号
  preemptStop   bool      // 抢占时将状态修改成 `_Gpreempted`
  preemptShrink bool      // 在同步安全点收缩栈
  lockedm        muintptr   //G 被锁定只能在这个 m 上运行
  waiting        *sudog     // 这个 g 当前正在阻塞的 sudog 结构体
  ......
}

type gobuf struct {
  sp   uintptr      // 栈指针
  pc   uintptr      // 程序计数器，记录G要执行的下一条指令位置
  g    guintptr     // 持有 runtime.gobuf 的 G
  ret  uintptr      // 系统调用的返回值
  ......
}

const (
  // _Gidle 表示 G 刚刚被分配并且还没有被初始化
  _Gidle = iota // 0
  // _Grunnable 表示 G  没有执行代码，没有栈的所有权，存储在运行队列中
  _Grunnable // 1
  // _Grunning 可以执行代码，拥有栈的所有权，被赋予了内核线程 M 和处理器 P
  _Grunning // 2
  // _Gsyscall 正在执行系统调用，拥有栈的所有权，没有执行用户代码，被赋予了内核线程 M 但是不在运行队列上
  _Gsyscall // 3
  // _Gwaiting 由于运行时而被阻塞，没有执行用户代码并且不在运行队列上，但是可能存在于 Channel 的等待队列上
  _Gwaiting // 4
  // _Gdead 没有被使用，没有执行代码，可能有分配的栈
  _Gdead // 6
  // _Gcopystack 栈正在被拷贝，没有执行代码，不在运行队列上
  _Gcopystack // 8
  // _Gpreempted 由于抢占而被阻塞，没有执行用户代码并且不在运行队列上，等待唤醒
  _Gpreempted // 9
  // _Gscan GC 正在扫描栈空间，没有执行代码，可以与其他状态同时存在
  _Gscan          = 0x1000
  ......
)

// src/runtime/runtime2.gotype m struct {
  g0            *g          // 持有调度栈的 G
  gsignal       *g                // 处理 signal 的 g
  tls           [tlsSlots]uintptr // 线程本地存储        mstartfn      func()      // M的起始函数，go语句携带的那个函数
  curg          *g          // 在当前线程上运行的 G
  p             puintptr    // 执行 go 代码时持有的 p (如果没有执行则为 nil)
  nextp         puintptr    // 用于暂存与当前 M 有潜在关联的 P
  oldp          puintptr    // 执行系统调用前绑定的 P
  spinning      bool        // 表示当前 M 是否正在寻找 G，在寻找过程中 M 处于自旋状态
  lockedg       guintptr    // 表示与当前 M 锁定的那个 G
  .....
}

// src/runtime/runtime2.gotype p struct {
	status      uint32      // p 的状态 pidle/prunning/...
	schedtick   uint32      // 每次执行调度器调度 +1
	syscalltick uint32      // 每次执行系统调用 +1
	m           muintptr    // 关联的 m 
	mcache      *mcache     // 用于 P 所在的线程 M 的内存分配的 mcache
	deferpool    []*_defer  // 本地 P 队列的 defer 结构体池
	// 可运行的 Goroutine 队列，可无锁访问
	runqhead uint32
	runqtail uint32
	runq     [256]guintptr
	// 线程下一个需要执行的 G
	runnext guintptr
	// 空闲的 G 队列，G 状态 status 为 _Gdead，可重新初始化使用
	gFree struct {
		gList
		n int32
	}
        ......
}

// src/runtime/runtime2.gotype schedt struct {
  lock mutex            // schedt的锁
  midle        muintptr // 空闲的M列表
  nmidle       int32    // 空闲的M列表的数量
  nmidlelocked int32    // 被锁定正在工作的M数
  mnext        int64    // 下一个被创建的 M 的 ID
  maxmcount    int32    // 能拥有的最大数量的 M
  pidle      puintptr   // 空闲的 P 链表
  npidle     uint32     // 空闲 P 数量
  nmspinning uint32     // 处于自旋状态的 M 的数量
  // 全局可执行的 G 列表
  runq     gQueue
  runqsize int32        // 全局可执行 G 列表的大小
  // 全局 _Gdead 状态的空闲 G 列表
  gFree struct {
    lock    mutex
    stack   gList // Gs with stacks
    noStack gList // Gs without stacks
    n       int32
  }
  // sudog结构的集中存储
  sudoglock  mutex
  sudogcache *sudog
  // 有效的 defer 结构池
  deferlock mutex
  deferpool *_defer
        ......
}

// src/runtime/runtime2.go
var (
  allm       *m         // 所有的 M
  gomaxprocs int32      // P 的个数，默认为 ncpu 核数
  ncpu       int32
  ......
  sched      schedt     // schedt 全局结构体
  newprocs   int32
​
  allpLock mutex       // 全局 P 队列的锁
  allp []*p            // 全局 P 队列，个数为 gomaxprocs
        ......
}

// src/runtime/proc.go var (
  m0           m       //  进程启动后的初始线程
  g0            g      //  代表着初始线程的stack
  ......
)

package main

import "fmt"

func main() {
	fmt.Println("hello world")
}

TEXT _rt0_amd64_linux(SB),NOSPLIT,$-8
	JMP	_rt0_amd64(SB)
TEXT _rt0_amd64_darwin(SB),NOSPLIT,$-8
	JMP	_rt0_amd64(SB)

TEXT _rt0_amd64(SB),NOSPLIT,$-8
	MOVQ	0(SP), DI	// argc
	LEAQ	8(SP), SI	// argv
	JMP	runtime·rt0_go(SB)

TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
	......
	// 初始化g0
	MOVD	$runtime·g0(SB), g
        ......
	// 初始化 m0
	MOVD	$runtime·m0(SB), R0// 绑定 g0 和 m0
	MOVD	g, m_g0(R0)
	MOVD	R0, g_m(g)
        ......
	BL	runtime·schedinit(SB)      // 调度器初始化

	// 创建一个新的 goroutine 来启动程序
	MOVD	$runtime·mainPC(SB), R0	   // main函数入口	
	.......
        BL	runtime·newproc(SB)        // 负责根据主函数即 main 的入口地址创建可被运行时调度的执行单元goroutine
	.......

	// 开始启动调度器的调度循环
	BL	runtime·mstart(SB)
	......

DATA	runtime·mainPC+0(SB)/8,$runtime·main<ABIInternal>(SB)    // main函数入口地址
GLOBL	runtime·mainPC(SB),RODATA,$8

// src/runtime/proc.go
// 调度器初始化
func schedinit() {
	......
	_g_ := getg()   
	......        // 设置机器线程数M最大为10000
	sched.maxmcount = 10000
        ......
	// 栈、内存分配器相关初始化
	stackinit()          // 初始化栈
	mallocinit()         // 初始化内存分配器
	......
	// 初始化当前系统线程 M0
	mcommoninit(_g_.m, -1)
	......
        // GC初始化
	gcinit()
        ......
        // 设置P的值为GOMAXPROCS个数
	procs := ncpu
	if n, ok := atoi32(gogetenv("GOMAXPROCS")); ok && n > 0 {
		procs = n
	}
        // 调用procresize调整 P 列表
	if procresize(procs) != nil {
		throw("unknown runnable goroutine during bootstrap")
	}
	......
}

// src/runtime/proc.gofunc mcommoninit(mp *m, id int64) {
        ......
  lock(&sched.lock)
​
  if id >= 0 {
    mp.id = id
  } else { // mReserveID() 会返回 sched.mnext 给当前 m，并对 sched.mnext++，记录新增加的这个 M 到 schedt 全局结构体
    mp.id = mReserveID()
  }
​
  ......
​
  // 添加到 allm 中
  mp.alllink = allm
​
  // 等价于 allm = mp
  atomicstorep(unsafe.Pointer(&allm), unsafe.Pointer(mp))
  unlock(&sched.lock)
        ......
}

// src/runtime/proc.go
func procresize(nprocs int32) *p {
  ......
        // 获取先前的 P 个数
  old := gomaxprocs
  ......
  // 如果全局变量 allp 切片中的处理器数量少于期望数量，对 allp 扩容
  if nprocs > int32(len(allp)) {
    // 加锁
    lock(&allpLock)
    if nprocs <= int32(cap(allp)) { // 如果要达到的 P 个数 nprocs 小于当前全局 P 切片到容量
      allp = allp[:nprocs]    // 在当前全局 P 切片上截取前 nprocs 个 P
    } else {                        // 否则，调大了，超出全局 P 切片的容量，创建容量为 nprocs 的新的 P 切片
      nallp := make([]*p, nprocs)
      // 将原有的 p 复制到新创建的 nallp 中
      copy(nallp, allp[:cap(allp)])
      allp = nallp  // 新的 nallp 切片赋值给旧的 allp
    }
                ......
    unlock(&allpLock)
  }
​
  // 使用 new 创建新的 P 结构体并调用 runtime.p.init 初始化刚刚扩容的allp列表里的 P
  for i := old; i < nprocs; i++ {
    pp := allp[i]                // 如果 p 是新创建的(新创建的 p 在数组中为 nil)，则申请新的 P 对象
    if pp == nil {
      pp = new(p)
    }
    pp.init(i)
    atomicstorep(unsafe.Pointer(&allp[i]), unsafe.Pointer(pp))
  }
​
  _g_ := getg()
        // 当前 G 的 M 上的 P 不为空，并且其 id 小于 nprocs，说明 ID 有效，则可以继续使用当前 G 的 P
  if _g_.m.p != 0 && _g_.m.p.ptr().id < nprocs {
    // 继续使用当前 P， 其状态设置为 _Prunning
    _g_.m.p.ptr().status = _Prunning
    _g_.m.p.ptr().mcache.prepareForSweep()
  } else {
    // 否则，释放当前 P 并获取 allp[0]
    if _g_.m.p != 0 {
      ......
      _g_.m.p.ptr().m = 0
    }
    _g_.m.p = 0
                // 将处理器 allp[0] 绑定到当前 M
    p := allp[0]
    p.m = 0
    p.status = _Pidle  // P 状态设置为 _Pidle 
    acquirep(p)        // 将allp[0]绑定到当前的 M
    if trace.enabled {
      traceGoStart()
    }
  }
​
  
  mcache0 = nil
​
  // 调用 runtime.p.destroy 释放从未使用的 P
  for i := nprocs; i < old; i++ {
    p := allp[i]
    p.destroy()
    // 不能释放 p 本身，因为他可能在 m 进入系统调用时被引用
  }
​
  // 裁剪 allp，保证allp长度与期望处理器数量相等
  if int32(len(allp)) != nprocs {
    lock(&allpLock)
    allp = allp[:nprocs]
    idlepMask = idlepMask[:maskWords]
    timerpMask = timerpMask[:maskWords]
    unlock(&allpLock)
  }
​
  var runnablePs *p
        // 将除 allp[0] 之外的处理器 P 全部设置成 _Pidle 并加入到全局的空闲队列中
  for i := nprocs - 1; i >= 0; i-- {
    p := allp[i]
    if _g_.m.p.ptr() == p {    // 跳过当前 P
      continue
    }
    p.status = _Pidle          // 设置 P 的状态为空闲状态
    if runqempty(p) {
      pidleput(p)        // 放入到全局结构体 schedt 的空闲 P 列表中
    } else {
      p.m.set(mget())    // 如果有本地任务，则为其绑定一个 M
      p.link.set(runnablePs)
      runnablePs = p
    }
  }
  stealOrder.reset(uint32(nprocs))
  var int32p *int32 = &gomaxprocs 
  atomic.Store((*uint32)(unsafe.Pointer(int32p)), uint32(nprocs))
  return runnablePs      // 返回所有包含本地任务的 P 链表
}

// src/runtime/proc.go
// 初始化 P
func (pp *p) init(id int32) {
	pp.id = id             // p 的 id 就是它在 allp 中的索引
	pp.status = _Pgcstop   // 新创建的 p 处于 _Pgcstop 状态
	......
        // 为 P 分配 cache 对象，涉及对象分配
	if pp.mcache == nil {
		if id == 0 {
			if mcache0 == nil {
				throw("missing mcache?")
			}
			pp.mcache = mcache0
		} else {
			pp.mcache = allocmcache()
		}
	}
	......
}

// src/runtime/proc.go
// 创建G，并放入 P 的运行队列
func newproc(fn *funcval) {
  gp := getg()
  pc := getcallerpc()    // 获取调用方 PC 寄存器值，即调用方程序要执行的下一个指令地址        // 用 g0 系统栈创建 Goroutine 对象        // 传递的参数包括 fn 函数入口地址, gp（g0），调用方 pc
  systemstack(func() {
    newg := newproc1(fn, gp, pc)  // 调用 newproc1 获取 Goroutine 结构
​
    _p_ := getg().m.p.ptr()       // 获取当前 G 的 P 
    runqput(_p_, newg, true)      // 将新的 G 放入 P 的本地运行队列
​
    if mainStarted {              // M 启动时唤醒新的 P 执行 G
      wakep()
    }
  })
}

// src/runtime/proc.go
// 创建一个运行fn函数的goroutine
func newproc1(fn *funcval, callergp *g, callerpc uintptr) *g {
  _g_ := getg()       // 因为是在系统栈运行所以此时的 g 为 g0
​
  if fn == nil {
    _g_.m.throwing = -1 // do not dump full stacks
    throw("go of nil func value")
  }
  acquirem() // 加锁，禁止这时 G 的 M 被抢占，因为它可以在一个局部变量中保存 P
​
  _p_ := _g_.m.p.ptr()         // 获取 P
  newg := gfget(_p_)           // 从 P 的空闲列表获取一个空闲的 G
  if newg == nil {             // 找不到则创建
    newg = malg(_StackMin)     // 创建一个栈大小为 2K 的 G
    casgstatus(newg, _Gidle, _Gdead)     // CAS 改变 G 的状态为_Gdead
    allgadd(newg) // 将 _Gdead 状态的 g 添加到 allg，这样 GC 不会扫描未初始化的栈
  }
  ......
        // 计算运行空间大小，对齐
  totalSize := uintptr(4*goarch.PtrSize + sys.MinFrameSize) 
  totalSize = alignUp(totalSize, sys.StackAlign)
  sp := newg.stack.hi - totalSize       // 确定 SP 和参数入栈位置
  spArg := sp
  ......
        // 清理、创建并初始化 G 的运行现场
  memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
  newg.sched.sp = sp
  newg.stktopsp = sp// 保存goexit的地址到sched.pc
  newg.sched.pc = abi.FuncPCABI0(goexit) + sys.PCQuantum // +PCQuantum so that previous instruction is in same function
  newg.sched.g = guintptr(unsafe.Pointer(newg))
  gostartcallfn(&newg.sched, fn)
        // 初始化 G 的基本状态
  newg.gopc = callerpc
  newg.ancestors = saveAncestors(callergp)
  newg.startpc = fn.fn
  ......
        // 将 G 的状态设置为_Grunnable
  casgstatus(newg, _Gdead, _Grunnable)
  ......
        // 生成唯一的goid
  newg.goid = int64(_p_.goidcache)
  _p_.goidcache++
  ......
        // 释放对 M 加的锁
  releasem(_g_.m)
​
  return newg
}

// src/runtime/proc.go
func gfget(_p_ *p) *g {
retry:
        // 如果 P 的空闲列表 gFree 为空，sched 的的空闲列表 gFree 不为空
  if _p_.gFree.empty() && (!sched.gFree.stack.empty() || !sched.gFree.noStack.empty()) {
    lock(&sched.gFree.lock)
    // 从 sched 的 gFree 列表中移动 32 个 G 到 P 的 gFree 中
    for _p_.gFree.n < 32 {
      gp := sched.gFree.stack.pop()
      if gp == nil {
        gp = sched.gFree.noStack.pop()
        if gp == nil {
          break
        }
      }
      sched.gFree.n--
      _p_.gFree.push(gp)
      _p_.gFree.n++
    }
    unlock(&sched.gFree.lock)
    goto retry
  }
        // 如果此时 P 的空闲列表还是为空，返回nil，说明无空闲的G
  gp := _p_.gFree.pop()
  if gp == nil {
    return nil
  }
  _p_.gFree.n--
        // 设置 G 的栈空间
  if gp.stack.lo == 0 {
    systemstack(func() {
      gp.stack = stackalloc(_FixedStack)
    })
    gp.stackguard0 = gp.stack.lo + _StackGuard
  } else {
    .....
  }
  return gp   // 从 P 的空闲列表获取 G 返回
}

// src/runtime/proc.go
// 创建一个新的 g 结构体 
func malg(stacksize int32) *g {
  newg := new(g)
  if stacksize >= 0 {     // 如果申请的堆栈大小大于 0，会通过 runtime.stackalloc 分配 2KB 的栈空间
    stacksize = round2(_StackSystem + stacksize)
    systemstack(func() {
      newg.stack = stackalloc(uint32(stacksize))
    })
    newg.stackguard0 = newg.stack.lo + _StackGuard
    newg.stackguard1 = ^uintptr(0)
    *(*uintptr)(unsafe.Pointer(newg.stack.lo)) = 0
  }
  return newg
}

// src/runtime/proc.go
// 将 G 放入 P 的运行队列中
func runqput(_p_ *p, gp *g, next bool) {        // 保持一定的随机性，不将当前 G 设置为 P 的下一个执行的任务
  if randomizeScheduler && next && fastrandn(2) == 0 {
    next = false
  }
​
  if next {
  retryNext:
               // 将 G 放入到 P 的 runnext 变量中，作为下一个 P 执行的任务
    oldnext := _p_.runnext
    if !_p_.runnext.cas(oldnext, guintptr(unsafe.Pointer(gp))) {
      goto retryNext
    }
    if oldnext == 0 {
      return
    }
    // 获取原来的 runnext 存储的 G，放入 P 本地运行队列，或全局队列
    gp = oldnext.ptr()
  }
​
retry:
  h := atomic.LoadAcq(&_p_.runqhead) // 获取 P 环形队列的头和尾部指针
  t := _p_.runqtail
        // P 本地环形队列没有满，将 G 放入本地环形队列
  if t-h < uint32(len(_p_.runq)) {
    _p_.runq[t%uint32(len(_p_.runq))].set(gp)
    atomic.StoreRel(&_p_.runqtail, t+1) 
    return
  }
        // P 本地环形队列已满，将 G 放入全局队列
  if runqputslow(_p_, gp, h, t) {
    return
  }
  // 本地队列和全局队列没有满，则不会走到这里，否则循环尝试放入
  goto retry
}

// 将 G 和 P 本地队列的一部分放入全局队列
func runqputslow(_p_ *p, gp *g, h, t uint32) bool {
  var batch [len(_p_.runq)/2 + 1]*g   // 初始化一个本地队列长度一半 + 1 的 G 列表 batch
​
  // 首先，从 P 本地队列中获取一部分 G 放入初始化的列表 batch
  n := t - h
  n = n / 2
  if n != uint32(len(_p_.runq)/2) {
    throw("runqputslow: queue is not full")
  }
  for i := uint32(0); i < n; i++ { // 将 P 本地环形队列的前一半 G 放入batch
    batch[i] = _p_.runq[(h+i)%uint32(len(_p_.runq))].ptr()
  }
  if !atomic.CasRel(&_p_.runqhead, h, h+n) { // cas-release, commits consume
    return false
  }
  batch[n] = gp    // 将传入的 G 放入列表 batch 的尾部
​
  if randomizeScheduler {     // 打乱 batch 列表中G的顺序
    for i := uint32(1); i <= n; i++ {
      j := fastrandn(i + 1)
      batch[i], batch[j] = batch[j], batch[i]
    }
  }
​
  // 将 batch列表的 G 串成一个链表.
  for i := uint32(0); i < n; i++ {
    batch[i].schedlink.set(batch[i+1])
  }
  var q gQueue     // 将 batch 列表设置成 gQueue 队列
  q.head.set(batch[0])
  q.tail.set(batch[n])
​
  // 现在把 gQueue 队列放入全局队列
  lock(&sched.lock)
  globrunqputbatch(&q, int32(n+1))
  unlock(&sched.lock)
  return true
}

TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
  CALL  runtime·mstart0(SB)
  RET // not reached

// src/runtime/proc.go
func mstart0() {
  _g_ := getg()
  ......
        // 初始化 g0 的参数
  _g_.stackguard0 = _g_.stack.lo + _StackGuard
  _g_.stackguard1 = _g_.stackguard0
  mstart1()
​
  ......
  mexit(osStack)
}

// src/runtime/proc.go
func mstart1() {
  _g_ := getg()
​
  if _g_ != _g_.m.g0 {
    throw("bad runtime·mstart")
  }
​
  // 记录当前栈帧，便于其他调用复用，当进入 schedule 之后，再也不会回到 mstart1
  _g_.sched.g = guintptr(unsafe.Pointer(_g_))
  _g_.sched.pc = getcallerpc()
  _g_.sched.sp = getcallersp()
​
  asminit()
  minit()
​
  // 设置信号 handler；在 minit 之后，因为 minit 可以准备处理信号的的线程
  if _g_.m == &m0 {
    mstartm0()
  }
        // 执行启动函数
  if fn := _g_.m.mstartfn; fn != nil {
    fn()
  }
        // 如果当前 m 并非 m0，则要求绑定 p
  if _g_.m != &m0 {
    acquirep(_g_.m.nextp.ptr())
    _g_.m.nextp = 0
  }
        // 准备好后，开始调度循环，永不返回
  schedule()
}

// src/runtime/proc.go
func schedule() {
  _g_ := getg()
​
  if _g_.m.locks != 0 {
    throw("schedule: holding locks")
  }
  ......
top:
  pp := _g_.m.p.ptr()
  pp.preempt = false
​
  if sched.gcwaiting != 0 {    // 如果需要 GC，不再进行调度
    gcstopm()
    goto top
  }
  if pp.runSafePointFn != 0 {  // 不等于0，说明在安全点
    runSafePointFn()
  }
​
  // 如果 G 所在的 M 在自旋，说明其P运行队列为空，如果不为空，则应该甩出错误
  if _g_.m.spinning && (pp.runnext != 0 || pp.runqhead != pp.runqtail) {
    throw("schedule: spinning with local work")
  }
        // 运行 P 上准备就绪的 Timer
  checkTimers(pp, 0)
​
  var gp *g
  var inheritTime bool
        ......
  if gp == nil {    // 说明不在 GC
    // 每调度 61 次，就检查一次全局队列，保证公平性；否则两个 Goroutine 可以通过互换，一直占领本地的 runqueue
    if _g_.m.p.ptr().schedtick%61 == 0 && sched.runqsize > 0 {
      lock(&sched.lock)
      gp = globrunqget(_g_.m.p.ptr(), 1)     // 从全局队列中偷 g
      unlock(&sched.lock)
    }
  }
  if gp == nil {
                // 从 P 的本地队列获取 G
    gp, inheritTime = runqget(_g_.m.p.ptr())
  }
  if gp == nil {
    gp, inheritTime = findrunnable() // 阻塞式查找可用 G
  }
​
  // M 这时候一定是获取到了G
  // 如果 M 是自旋状态，重置其状态到非自旋
  if _g_.m.spinning {
    resetspinning()
  }
        .......
  // 执行 G
  execute(gp, inheritTime)
}

// 从全局队列获取 G
func globrunqget(_p_ *p, max int32) *g {
  assertLockHeld(&sched.lock)
        // 如果全局队列没有 G，则直接返回
  if sched.runqsize == 0 {
    return nil
  }
        // 计算n，表示从全局队列放入本地队列的 G 的个数
  n := sched.runqsize/gomaxprocs + 1
  if n > sched.runqsize {
    n = sched.runqsize
  }
        // n 不能超过取的要获取的max个数 
  if max > 0 && n > max {
    n = max
  }
        // 计算能不能用本地队列的一般放下 n 个 G，如果放不下，则 n 设为本地队列的一半
  if n > int32(len(_p_.runq))/2 {
    n = int32(len(_p_.runq)) / 2
  }
​
  sched.runqsize -= n
        // 拿到全局队列的队头作为返回的 G
  gp := sched.runq.pop()   
  n--   // n计数减 1
        // 继续取剩下的 n-1个全局队列 G 放入本地队列
  for ; n > 0; n-- {
    gp1 := sched.runq.pop()
    runqput(_p_, gp1, false)
  }
  return gp
}

// 从 P 本地队列中获取 G
func runqget(_p_ *p) (gp *g, inheritTime bool) {
  // 如果 P 有一个 runnext，则它就是下一个要执行的 G.
  next := _p_.runnext
  // 如果 runnext 不为空，而 CAS 失败, 则它又可能被其他 P 偷取了,
  // 因为其他 P 可以竞争机会到设置 runnext 为 0, 当前 P 只能设置该字段为非0
  if next != 0 && _p_.runnext.cas(next, 0) {
    return next.ptr(), true
  }
​
  for {
    h := atomic.LoadAcq(&_p_.runqhead) //从本地环形队列头遍历
    t := _p_.runqtail
    if t == h {    // 头尾指针相等，表示本地队列为空
      return nil, false
    }
                // 获取头部指针指向的 G
    gp := _p_.runq[h%uint32(len(_p_.runq))].ptr()
    if atomic.CasRel(&_p_.runqhead, h, h+1) { 
      return gp, false
    }
  }
}

// 找到一个可运行的 G 去执行
// 会从其他 P 的运行队列偷取，从本地会全局队列获取，或从网络轮询器获取
func findrunnable() (gp *g, inheritTime bool) {
  _g_ := getg()
​
top:
  _p_ := _g_.m.p.ptr()
  if sched.gcwaiting != 0 {     // 如果在 gc，则休眠当前 m，直到复始后回到 top
    gcstopm()
    goto top
  }
  if _p_.runSafePointFn != 0 {  // 不等于0，说明在安全点
    runSafePointFn()
  }
​
  now, pollUntil, _ := checkTimers(_p_, 0)
  
​
  // 取本地队列 local runq，如果已经拿到，立刻返回
  if gp, inheritTime := runqget(_p_); gp != nil {
    return gp, inheritTime
  }
​
  // 全局队列 global runq，如果已经拿到，立刻返回
  if sched.runqsize != 0 {
    lock(&sched.lock)
    gp := globrunqget(_p_, 0)
    unlock(&sched.lock)
    if gp != nil {
      return gp, false
    }
  }
​
  // 从 netpoll 网络轮询器中尝试获取 G，优先级比从其他 P 偷取 G 要高
  if netpollinited() && atomic.Load(&netpollWaiters) > 0 && atomic.Load64(&sched.lastpoll) != 0 {
    if list := netpoll(0); !list.empty() { // non-blocking
      gp := list.pop()
      injectglist(&list)
      casgstatus(gp, _Gwaiting, _Grunnable)
      if trace.enabled {
        traceGoUnpark(gp, 0)
      }
      return gp, false
    }
  }
​
  // 自旋 M: 从其他 P 中窃取任务 G
  
  // 限制自旋 M 数量到忙碌P数量的一半. 避免一半P数量、并行机制很慢时的CPU消耗
  procs := uint32(gomaxprocs)
  if _g_.m.spinning || 2*atomic.Load(&sched.nmspinning) < procs-atomic.Load(&sched.npidle) {
    if !_g_.m.spinning {
      _g_.m.spinning = true
      atomic.Xadd(&sched.nmspinning, 1)
    }
                // 从其他 P 或 timer 中偷取G
    gp, inheritTime, tnow, w, newWork := stealWork(now)
    now = tnow
    if gp != nil {
      // Successfully stole.
      return gp, inheritTime
    }
    if newWork {
      // 可能有新的 timer 或 GC，重新开始
      goto top
    }
    if w != 0 && (pollUntil == 0 || w < pollUntil) {
      // Earlier timer to wait for.
      pollUntil = w
    }
  }
​
  // 没有任何 work 可做。        // 如果我们在 GC mark 阶段，则可以安全的扫描并标记对象为黑色        // 然后便有 work 可做，运行 idle-time 标记而非直接放弃当前的 P。
  if gcBlackenEnabled != 0 && gcMarkWorkAvailable(_p_) {
    node := (*gcBgMarkWorkerNode)(gcBgMarkWorkerPool.pop())
    if node != nil {
      _p_.gcMarkWorkerMode = gcMarkWorkerIdleMode
      gp := node.gp.ptr()
      casgstatus(gp, _Gwaiting, _Grunnable)
      if trace.enabled {
        traceGoUnpark(gp, 0)
      }
      return gp, false
    }
  }
        .....
  // 放弃当前的 P 之前，对 allp 做一个快照
  allpSnapshot := allp
  idlepMaskSnapshot := idlepMask
  timerpMaskSnapshot := timerpMask
​
  // 准备归还 p，对调度器加锁
  lock(&sched.lock)        // 进入了 gc，回到顶部并停止 m
  if sched.gcwaiting != 0 || _p_.runSafePointFn != 0 {
    unlock(&sched.lock)
    goto top
  }        // 全局队列中又发现了任务
  if sched.runqsize != 0 {
    gp := globrunqget(_p_, 0)     // 赶紧偷掉返回
    unlock(&sched.lock)
    return gp, false
  }
  if releasep() != _p_ {         // 归还当前的 p
    throw("findrunnable: wrong p")
  }
  pidleput(_p_)       // 将 p 放入 idle 链表
  unlock(&sched.lock)      // 完成归还，解锁
​
  // 这里要非常小心: 线程从自旋到非自旋状态的转换，可能与新 Goroutine 的提交同时发生
  wasSpinning := _g_.m.spinning
  if _g_.m.spinning {
    _g_.m.spinning = false    // M 即将睡眠，状态不再是 spinning
    if int32(atomic.Xadd(&sched.nmspinning, -1)) < 0 {
      throw("findrunnable: negative nmspinning")
    }
​
    // 再次检查所有的 runqueue
    _p_ = checkRunqsNoP(allpSnapshot, idlepMaskSnapshot)
    if _p_ != nil {
      acquirep(_p_)
      _g_.m.spinning = true
      atomic.Xadd(&sched.nmspinning, 1)
      goto top
    }
​
    // 再次检查 idle-priority GC work，和上面重新找 runqueue 的逻辑类似
    _p_, gp = checkIdleGCNoP()
    if _p_ != nil {
      acquirep(_p_)
      _g_.m.spinning = true
      atomic.Xadd(&sched.nmspinning, 1)
​
      // Run the idle worker.
      _p_.gcMarkWorkerMode = gcMarkWorkerIdleMode
      casgstatus(gp, _Gwaiting, _Grunnable)
      if trace.enabled {
        traceGoUnpark(gp, 0)
      }
      return gp, false
    }
​
    // 最后, 检查 timer creation
    pollUntil = checkTimersNoP(allpSnapshot, timerpMaskSnapshot, pollUntil)
  }
​
  // 再次检查 netpoll 网络轮询器，和上面重新找 runqueue 的逻辑类似
  if netpollinited() && (atomic.Load(&netpollWaiters) > 0 || pollUntil != 0) && atomic.Xchg64(&sched.lastpoll, 0) != 0 {
    ......
    lock(&sched.lock)
    _p_ = pidleget()
    unlock(&sched.lock)
    if _p_ == nil {
      injectglist(&list)
    } else {
      acquirep(_p_)
      if !list.empty() {
        gp := list.pop()
        injectglist(&list)
        casgstatus(gp, _Gwaiting, _Grunnable)
        if trace.enabled {
          traceGoUnpark(gp, 0)
        }
        return gp, false
      }
      if wasSpinning {
        _g_.m.spinning = true
        atomic.Xadd(&sched.nmspinning, 1)
      }
      goto top
    }
  } else if pollUntil != 0 && netpollinited() {
    pollerPollUntil := int64(atomic.Load64(&sched.pollUntil))
    if pollerPollUntil == 0 || pollerPollUntil > pollUntil {
      netpollBreak()
    }
  }
  stopm()     // 真的什么都没找到，暂止当前的 m
  goto top
}