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
	......
)

type 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
	.....
}

type 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 结构体池
	// 可运行的 G 队列，可无锁访问
	runqhead uint32
	runqtail uint32
	runq     [256]guintptr
	// 线程下一个需要执行的 G
	runnext guintptr
	// 空闲的 G 队列，G 状态 status 为 _Gdead，可重新初始化使用
	gFree struct {
		gList
		n int32
	}
	......
}

// src/runtime/runtime2.go
type 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
	......
}

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")
}

// src/runtime/proc.go
func schedinit() {
	// 获取当前的 G
	gp := getg()

	// 设置机器线程数M最大为10000
	sched.maxmcount = 10000

	// 栈、内存分配器初始化
	stackinit()
	mallocinit()

	// 初始化系统线程 M0，加到 schedt 全局结构体中
	mcommoninit(gp.m, -1)

	// GC初始化
	gcinit()

	// 设置 P 的数量为 GOMAXPROCS
	procs := ncpu
	if n, ok := atoi32(gogetenv("GOMAXPROCS")); ok && n > 0 {
		procs = n
	}
	// 初始化 P 列表
	if procresize(procs) != nil {
		throw("unknown runnable goroutine during bootstrap")
	}

	......
}

// src/runtime/proc.go
func mcommoninit(mp *m, id int64) { // id 传参 -1
	// 获取当前的 G
	gp := getg()

	lock(&sched.lock)

	if id >= 0 {
		mp.id = id
	} else {
		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
	if old < 0 || nprocs <= 0 {
		throw("procresize: invalid arg")
	}

	// 如果 P 数量大于 allp 长度，则进行扩容
	if nprocs > int32(len(allp)) {
		lock(&allpLock)
		if nprocs <= int32(cap(allp)) { // 切片 allp 容量足够
			allp = allp[:nprocs]
		} else { // 切片 allp 容量不够，新建切片并复制原有的 P 过来
			nallp := make([]*p, nprocs)
			copy(nallp, allp[:cap(allp)])
			allp = nallp
		}

		unlock(&allpLock)
	}

	// 对增加的 P 逐个初始化
	for i := old; i < nprocs; i++ {
		pp := allp[i]
		if pp == nil {
			pp = new(p)
		}
		pp.init(i) // 初始化 P
		atomicstorep(unsafe.Pointer(&allp[i]), unsafe.Pointer(pp)) // allp[i] = pp
	}

	// 获取当前的 G
	gp := getg()
	if gp.m.p != 0 && gp.m.p.ptr().id < nprocs { // 当前 G 的 M 有 P，且 id 小于 nprocs，继续使用当前 G 的 P
		gp.m.p.ptr().status = _Prunning // 设置 P 的状态为 _Prunning
		gp.m.p.ptr().mcache.prepareForSweep()
	} else { // 否则释放当前 P 并获取 allp[0]
		if gp.m.p != 0 {
			gp.m.p.ptr().m = 0
		}
		gp.m.p = 0
		pp := allp[0]
		pp.m = 0
		pp.status = _Pidle
		acquirep(pp) // 将 allp[0] 绑定到当前 M
	}

	// 释放不会用使到的 P
	for i := nprocs; i < old; i++ {
		pp := allp[i]
		pp.destroy()
	}

	// 修建多余的 allp
	if int32(len(allp)) != nprocs {
		lock(&allpLock)
		allp = allp[:nprocs]
		unlock(&allpLock)
	}

	// 将除 allp[0] 之外的处理器 P 全部设置成 _Pidle 并加入到全局的空闲队列中
	var runnablePs *p
	for i := nprocs - 1; i >= 0; i-- {
		pp := allp[i]
		if gp.m.p.ptr() == pp {
			continue
		}
		pp.status = _Pidle // 将其他 P 状态设置为 _Pidle
		if runqempty(pp) { // 对于没有 G 本地队列的 P，放到全局空闲队列
			pidleput(pp, now)
		} else { // 否则获取一个 M 并与 P 绑定
			pp.m.set(mget())
			pp.link.set(runnablePs)
			runnablePs = pp
		}
	}

	return runnablePs
}

// src/runtime/proc.go
func newproc(fn *funcval) {
	gp := getg()
	pc := getcallerpc() // 获取调用方 PC 寄存器值，即调用方程序要执行的下一个指令地址
	systemstack(func() { // 用 g0 系统栈创建 G
		newg := newproc1(fn, gp, pc) // 调用 newproc1 获取 G 结构

		pp := getg().m.p.ptr()
		runqput(pp, newg, true) // 将新创建的 G 放入 P 的本地队列

		if mainStarted { // M 启动时唤醒新的 P 执行 G
			wakep()
		}
	})
}

// src/runtime/proc.go
func newproc1(fn *funcval, callergp *g, callerpc uintptr) *g {
	mp := acquirem()
	pp := mp.p.ptr()
	newg := gfget(pp) // 从 P 的空闲队列获取一个空闲的 G
	if newg == nil { // 获取不到则创建
		newg = malg(stackMin) // 创建栈大小为 2KB 的 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
	spArg := sp

	// 清理、创建并初始化 G 的运行现场
	memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
	newg.sched.sp = sp
	newg.stktopsp = sp
	newg.sched.pc = abi.FuncPCABI0(goexit) + sys.PCQuantum
	newg.sched.g = guintptr(unsafe.Pointer(newg))
	gostartcallfn(&newg.sched, fn)
	newg.parentGoid = callergp.goid
	newg.gopc = callerpc
	newg.ancestors = saveAncestors(callergp)
	newg.startpc = fn.fn

	// 将 G 的状态设置为_Grunnable
	casgstatus(newg, _Gdead, _Grunnable)

	// 生成唯一的goid
	newg.goid = pp.goidcache
	pp.goidcache++

	// 释放对 M 加的锁
	releasem(mp)

	return newg
}

// src/runtime/proc.go
func mstart1() {
	gp := getg()

	if gp != gp.m.g0 {
		throw("bad runtime·mstart")
	}

	// 记录当前栈帧，便于其他调用复用，当进入 schedule 之后，再也不会回到 mstart1
	gp.sched.g = guintptr(unsafe.Pointer(gp))
	gp.sched.pc = getcallerpc()
	gp.sched.sp = getcallersp()

	asminit()
	minit()

	// 设置信号 handler；在 minit 之后，因为 minit 可以准备处理信号的的线程
	if gp.m == &m0 {
		mstartm0()
	}

	// 执行启动函数
	if fn := gp.m.mstartfn; fn != nil {
		fn()
	}

	// 如果当前 m 并非 m0，则要求绑定 p
	if gp.m != &m0 {
		acquirep(gp.m.nextp.ptr())
		gp.m.nextp = 0
	}
	// 开始调度循环，永不返回
	schedule()
}

// src/runtime/proc.go
func schedule() {
	mp := getg().m
	if mp.locks != 0 {
		throw("schedule: holding locks")
	}

	pp := mp.p.ptr()
	pp.preempt = false

	// 阻塞等待找到可用的 G
	gp, inheritTime, tryWakeP := findRunnable()

	// 获取到 G 后，如果 M 是自旋状态，则将状态重置为非自旋状态
	if mp.spinning {
		resetspinning()
	}

	// 如果当前的 G 是一个非普通的协程，如 GC 或者 tracereader，唤醒另一个 P 来调度 G
	if tryWakeP {
		wakep()
	}

	// 执行 G
	execute(gp, inheritTime)
}

// src/runtime/proc.go
func findRunnable() (gp *g, inheritTime, tryWakeP bool) {
	mp := getg().m

top:
	pp := mp.p.ptr()
	if sched.gcwaiting.Load() { // 如果正在 GC，则休眠当前的 M
		gcstopm()
		goto top
	}

	now, pollUntil, _ := checkTimers(pp, 0)

	// 为了保证公平性，每 61 次就检查一次全局队列，尝试从中取 G
	if pp.schedtick%61 == 0 && sched.runqsize > 0 {
		lock(&sched.lock)
		gp := globrunqget(pp, 1)
		unlock(&sched.lock)
		if gp != nil {
			return gp, false, false
		}
	}

	// 尝试从 P 的本地队列中取 G
	if gp, inheritTime := runqget(pp); gp != nil {
		return gp, inheritTime, false
	}

	// 尝试从全局队列中取 G
	if sched.runqsize != 0 {
		lock(&sched.lock)
		gp := globrunqget(pp, 0)
		unlock(&sched.lock)
		if gp != nil {
			return gp, false, false
		}
	}

	// 尝试从 netpoll 网络轮询器中获取 G
	if netpollinited() && netpollWaiters.Load() > 0 && sched.lastpoll.Load() != 0 {
		if list := netpoll(0); !list.empty() { // non-blocking
			gp := list.pop()
			injectglist(&list)
			casgstatus(gp, _Gwaiting, _Grunnable)
			if traceEnabled() {
				traceGoUnpark(gp, 0)
			}
			return gp, false, false
		}
	}

	// 如果 M 处于自旋状态，从其他 P 偷取 G
	// 偷取的数量是忙碌 P 数量的一半
	if mp.spinning || 2*sched.nmspinning.Load() < gomaxprocs-sched.npidle.Load() {
		if !mp.spinning {
			mp.becomeSpinning()
		}

		gp, inheritTime, tnow, w, newWork := stealWork(now)
		if gp != nil {
			// Successfully stole.
			return gp, inheritTime, false
		}
		if newWork {
			// There may be new timer or GC work; restart to
			// discover.
			goto top
		}

		now = tnow
		if w != 0 && (pollUntil == 0 || w < pollUntil) {
			// Earlier timer to wait for.
			pollUntil = w
		}
	}

	// 无事可做且处在 GC mark 阶段，则扫描标记对象为黑色
	if gcBlackenEnabled != 0 && gcMarkWorkAvailable(pp) && gcController.addIdleMarkWorker() {
		node := (*gcBgMarkWorkerNode)(gcBgMarkWorkerPool.pop())
		if node != nil {
			pp.gcMarkWorkerMode = gcMarkWorkerIdleMode
			gp := node.gp.ptr()
			casgstatus(gp, _Gwaiting, _Grunnable)
			if traceEnabled() {
				traceGoUnpark(gp, 0)
			}
			return gp, false, false
		}
		gcController.removeIdleMarkWorker()
	}

	// 放弃 P 之前，给 allp 做一个快照
	allpSnapshot := allp
	idlepMaskSnapshot := idlepMask
	timerpMaskSnapshot := timerpMask

	// 归还 P 并加锁
	lock(&sched.lock)
	if sched.gcwaiting.Load() || pp.runSafePointFn != 0 {
		unlock(&sched.lock)
		goto top
	}
	if sched.runqsize != 0 {// 全局队列中又发现了任务，则返回
		gp := globrunqget(pp, 0)
		unlock(&sched.lock)
		return gp, false, false
	}
	if !mp.spinning && sched.needspinning.Load() == 1 {
		mp.becomeSpinning()
		unlock(&sched.lock)
		goto top
	}
	if releasep() != pp { // 归还 P
		throw("findrunnable: wrong p")
	}
	now = pidleput(pp, now) // 将 p 放入 idle 链表
	unlock(&sched.lock)

	// M 变为非自旋
	wasSpinning := mp.spinning
	if mp.spinning {
		mp.spinning = false
		if sched.nmspinning.Add(-1) < 0 {
			throw("findrunnable: negative nmspinning")
		}

		// 再次检查所有的 runqueue
		pp := checkRunqsNoP(allpSnapshot, idlepMaskSnapshot)
		if pp != nil {
			acquirep(pp)
			mp.becomeSpinning()
			goto top
		}

		// 再次检查 idle-priority GC work
		pp, gp := checkIdleGCNoP()
		if pp != nil {
			acquirep(pp)
			mp.becomeSpinning()

			// Run the idle worker.
			pp.gcMarkWorkerMode = gcMarkWorkerIdleMode
			casgstatus(gp, _Gwaiting, _Grunnable)
			if traceEnabled() {
				traceGoUnpark(gp, 0)
			}
			return gp, false, false
		}

		// 最后检查 timer creation
		pollUntil = checkTimersNoP(allpSnapshot, timerpMaskSnapshot, pollUntil)
	}

	// 再次检查 netpoll 网络轮询器
	if netpollinited() && (netpollWaiters.Load() > 0 || pollUntil != 0) && sched.lastpoll.Swap(0) != 0 {
		lock(&sched.lock)
		pp, _ := pidleget(now)
		unlock(&sched.lock)
		if pp == nil {
			injectglist(&list)
		} else {
			acquirep(pp)
			if !list.empty() {
				gp := list.pop()
				injectglist(&list)
				casgstatus(gp, _Gwaiting, _Grunnable)
				if traceEnabled() {
					traceGoUnpark(gp, 0)
				}
				return gp, false, false
			}
			if wasSpinning {
				mp.becomeSpinning()
			}
			goto top
		}
	} else if pollUntil != 0 && netpollinited() {
		pollerPollUntil := sched.pollUntil.Load()
		if pollerPollUntil == 0 || pollerPollUntil > pollUntil {
			netpollBreak()
		}
	}
	stopm() // 没有找到任何工作，暂停当前 M
	goto top
}

// src/runtime/proc.go
func execute(gp *g, inheritTime bool) {
	mp := getg().m

	// 给 G 的字段赋值
	mp.curg = gp
	gp.m = mp
	casgstatus(gp, _Grunnable, _Grunning) // 用 CAS 的方式修改状态
	gp.waitsince = 0
	gp.preempt = false
	gp.stackguard0 = gp.stack.lo + stackGuard
	if !inheritTime {
		mp.p.ptr().schedtick++
	}

	// 执行 G
	gogo(&gp.sched)
}

// src/runtime/proc.go
func runqget(pp *p) (gp *g, inheritTime bool) {
	// 如果 runnext 不为空，直接获取返回
	next := pp.runnext
	if next != 0 && pp.runnext.cas(next, 0) {
		return next.ptr(), true
	}

	// 从本地队列头指针遍历本地队列
	for {
		h := atomic.LoadAcq(&pp.runqhead)
		t := pp.runqtail
		if t == h { // 本地队列为空
			return nil, false
		}
		gp := pp.runq[h%uint32(len(pp.runq))].ptr()
		if atomic.CasRel(&pp.runqhead, h, h+1) { // cas-release, commits consume
			return gp, false
		}
	}
}

// src/runtime/proc.go
func globrunqget(pp *p, max int32) *g {
	// 如果全局队列中没有 G 直接返回
	if sched.runqsize == 0 {
		return nil
	}

	// 全局队列长度处以 P 的数量，避免拿太多
	n := sched.runqsize/gomaxprocs + 1
	if n > sched.runqsize {
		n = sched.runqsize
	}
	if max > 0 && n > max {
		n = max
	}
	if n > int32(len(pp.runq))/2 {
		n = int32(len(pp.runq)) / 2
	}

	// 全局队列减去拿走的 G
	sched.runqsize -= n
	// 从全局队列取出一个 G 返回
	gp := sched.runq.pop()
	n--
	for ; n > 0; n-- { // 其余要从全局队列取出的 G 放入 P 的本地队列
		gp1 := sched.runq.pop()
		runqput(pp, gp1, false)
	}
	return gp
}