Go runtime 调度器

// 栈
type stack struct {
    // 栈下界指针
    lo uintptr
    // 栈上界指针
    hi uintptr
}
// 代表一个 goroutine
type g struct {
    // 描述当前 g 的栈信息
    stack       stack
    // 栈界限 (守卫), 用于一般 goroutine
    stackguard0 uintptr
    // 栈界限 (守卫), 用于 g0 和 gsignal
    stackguard1 uintptr
    // 如果 G 正在运行, m 指向运行当前 goroutine 的 M
    m           *m
    //goroutine 现场信息, 在 goroutine 切换的时候需要保存和恢复该信息
    sched       gobuf
    // 当前 G 的状态 (参考 runtime/runtime2.go#14)
    atomicstatus   uint32
    // 标记是否要抢占式调度
    preempt        bool
    // 锁定 M, 即表示当前的 G 具有线程亲和性, 需要在制定的线程中执行
    lockedm     *m
    // 其他字段
    ...
}

type m struct {
    // 拥有调度栈的 goroutine
    g0      *g
    // 处理信号的 goroutine
    gsignal *g
    // 附加在当前 M 上的 P, 如果当前 M 处于空闲状态, p 为 nil
    p        puintptr
    // 操作系统线程 handle
    thread   uintptr
    // 为 true 说明当前线程正处于没事找事的状态
    spinning bool
    // 其他字段
    ...
}

type p struct {
    // 处理器状态 (参考 runtime/runtime2.go#91)
    status      uint32
    // 关联的线程 M 信息, 如果 P 处于空闲状态, m 为 nil
    m           muintptr
    // 当前 P 所持有的 G 队列, P 处于运行状态时从该队列中 pop 出一个 G 来执行
    runqhead uint32
    runqtail uint32
    runq     [256]guintptr
    // 处于死亡状态的 G, 作为对象池来使用
    // 当前 P 上的 G 新建 goroutine 的时候会先从这里取出已经死亡的 G 来使用, 避免频繁创建 G 结构体
    gfree    *g
    gfreecnt int32
    // 其他字段
    ...
}

// sysmon 运行过程中不需要 P，总是独占一个线程
func sysmon() {
    // 记录下面的 for 循环连续没事做的次数
	idle := 0
    // 延迟时间, 即下次运行前 sleep 的时间
	delay := uint32(0)
	for {
		if idle == 0 {
            // 如果上次循环的时候就有事做，那么下次做事前先休息 20 微秒
			delay = 20
		} else if idle > 50 {
            // 如果前面 50 次循环都没有事情做，那么睡眠时间开始增长
			delay *= 2
		}
		if delay > 10*1000 {
            // 睡眠时间不能超过 10ms
			delay = 10 * 1000
		}
        // 调用操作系统的 sleep 函数让 M(操作系统线程) 休眠, 与 time.Sleep 不同, time.Sleep 只会让 G 休眠而不会让 M 休眠
		usleep(delay)
        // 忽略部分代码
        ...
        // 检查网络状态, 即对于那些因网络调用而阻塞的 G, 在此处检查相应状态, 如果状态符合要求就将对应的 G 从 Gwaiting 转换为 Grunnable
		// poll network if not polled for more than 10ms
		lastpoll := int64(atomic.Load64(&sched.lastpoll))
		now := nanotime()
		unixnow := unixnanotime()
		if lastpoll != 0 && lastpoll+10*1000*1000 < now {
			atomic.Cas64(&sched.lastpoll, uint64(lastpoll), uint64(now))
			gp := netpoll(false) // non-blocking - returns list of goroutines
			if gp != nil {
				// Need to decrement number of idle locked M's
				// (pretending that one more is running) before injectglist.
				// Otherwise it can lead to the following situation:
				// injectglist grabs all P's but before it starts M's to run the P's,
				// another M returns from syscall, finishes running its G,
				// observes that there is no work to do and no other running M's
				// and reports deadlock.
				incidlelocked(-1)
				injectglist(gp)
				incidlelocked(1)
			}
		}
        // 在此处检查处于 SYSCALL 的 P 并进行处理
		//retake 还检查了执行过长的 G
		if retake(now) != 0 {
			idle = 0
		} else {
			idle++
		}
		// 检查是否需要 GC
		lastgc := int64(atomic.Load64(&memstats.last_gc))
		if gcphase == _GCoff && lastgc != 0 && unixnow-lastgc > forcegcperiod && atomic.Load(&forcegc.idle) != 0 {
			lock(&forcegc.lock)
			forcegc.idle = 0
			forcegc.g.schedlink = 0
			injectglist(forcegc.g)
			unlock(&forcegc.lock)
		}
		// scavenge heap once in a while
		if lastscavenge+scavengelimit/2 < now {
			mheap_.scavenge(int32(nscavenge), uint64(now), uint64(scavengelimit))
			lastscavenge = now
			nscavenge++
		}
		if debug.schedtrace > 0 && lasttrace+int64(debug.schedtrace)*1000000 <= now {
			lasttrace = now
			schedtrace(debug.scheddetail > 0)
		}
	}
}

func retake(now int64) uint32 {
	n := 0
    // 遍历所有的 P
	for i := int32(0); i < gomaxprocs; i++ {
		_p_ := allp[i]
		if _p_ == nil {
			continue
		}
		pd := &pdesc[i]
		s := _p_.status
		if s == _Psyscall {
            // 超过一次 sysmon 循环所需要的时间的 P, 才会被 retake 处理, 具体时间由 sysmon 的 delay 决定, 最少 20 微秒
			// Retake P from syscall if it's there for more than 1 sysmon tick (at least 20us).
			t := int64(_p_.syscalltick)
			if int64(pd.syscalltick) != t {
				pd.syscalltick = uint32(t)
				pd.syscallwhen = now
				continue
			}
			// On the one hand we don't want to retake Ps if there is no other work to do,
			// but on the other hand we want to retake them eventually
			// because they can prevent the sysmon thread from deep sleep.
			if runqempty(_p_) && atomic.Load(&sched.nmspinning)+atomic.Load(&sched.npidle) > 0 && pd.syscallwhen+10*1000*1000 > now {
				continue
			}
			// Need to decrement number of idle locked M's
			// (pretending that one more is running) before the CAS.
			// Otherwise the M from which we retake can exit the syscall,
			// increment nmidle and report deadlock.
			incidlelocked(-1)
			if atomic.Cas(&_p_.status, s, _Pidle) {
				if trace.enabled {
					traceGoSysBlock(_p_)
					traceProcStop(_p_)
				}
				n++
				_p_.syscalltick++
				handoffp(_p_)
			}
			incidlelocked(1)
		} else if s == _Prunning {
            // 如果 P 处于运行状态, 并且 G 运行时间太久了, 那么就对 G 进行抢占
			// Preempt G if it's running for too long.
			t := int64(_p_.schedtick)
			if int64(pd.schedtick) != t {
				pd.schedtick = uint32(t)
				pd.schedwhen = now
				continue
			}
			if pd.schedwhen+forcePreemptNS > now {
				continue
			}
			preemptone(_p_)
		}
	}
	return uint32(n)
}