type g struct {
    stack       stack   // 执行栈, 描述了当前Goroutine 的栈内存范围 (lo ~ hi)
    stackguard0 uintptr // 用于检测堆栈是否溢出(扩容或抢占)
    stackguard1 uintptr // 用于检测C堆栈是否溢出

    _panic       *_panic // 指向 panic栈 最内测的对象
    _defer       *_defer // 指向 defer(延迟函数) 最内测的对象

    m            *m      // 当前 Goroutine 占用的 M (可能为空)
    sched        gobuf   // pc, sp, lr 等上下文数据
    ...
    param        unsafe.Pointer
    stktopsp     uintptr        // sp期望栈顶, 用于回溯检查
    param        unsafe.Pointer // 唤醒时候传递的参数
    atomicstatus uint32         // Goroutine 状态(_Gidle, _Grunnable, _Grunning ...)
    stackLock    uint32         // stack Lock
    goid         int64          // Goroutine Id 对开发者不可见，Go 团队认为引入 ID 会让部分 Goroutine 变得更特殊，从而限制语言的并发能力；
    ...
    waitsince    int64          // 阻塞的开始时间
    waitreason   waitReason     // 阻塞的原因
    preempt       bool          // 抢占信号
    ...
    timer         *timer        // 为 time.Sleep 缓存的计时器
    ...
}

type stack struct {       // 用于描述 Go 的执行栈
    lo uintptr            // 下边界
    hi uintptr            // 上边界
}

type gobuf struct {       // 用于 保存、恢复 上下文
    sp   uintptr          // 栈指针
    pc   uintptr          // 程序计数器
    g    guintptr         // 持有 gobuf 的 g 指针
    ctxt unsafe.Pointer
    ret  sys.Uintreg      // 系统调用的返回值
    ...
}

type m struct {
    g0      *g                 // m 持有的 Goroutine 用于执行调度指令
    ...
    procid        uint64       // 底层线程id (PID)
    gsignal       *g           //  处理 signal 的 Goroutine
    ...
    tls           [6]uintptr   // 本地线程存储 (传给 FS寄存器的线程局部存储)
    mstartfn      func()       // m 启动时的函数
    curg          *g           // 当前正在运行( 执行代码 ) 的 Goroutine
    ...
    p             puintptr     // m 执行代码时持有的 p (没有执行代码时为 nil )
    nextp         puintptr     // 暂存的 p
    oldp          puintptr     // 执行系统调用之前使用 执行程序的 p
    id            int64        // id
    spinning      bool         // m 没有可以执行的 g, 正在寻找可以执行的 g (自旋 spin)； 其实 m 就两个状态 自旋(spinning) 和 运行(runing)
    ...
    incgo         bool         // m 正在执行 CGO 调用
    ...
    mcache        *mcache      // 运行代码是 绑定的 p 的 mache
    ...
}

type p struct {
    id            int32        // p id
    status        uint32       // p 的状态; _Pidle, _Prunning...
    ...
    m             muintptr     // 反向链接到关联的 m （nil 则表示 idle）
    mcache        *mcache      // pre-p的分配cache
    pcache        pageCache    // 页面缓存
    ...
    deferpool     [5][]*_defer // 不同大小的可用的 defer 结构池
    deferpoolbuf  [5][32]*_defer
    runqhead      uint32       // p 的运行队列头
    runqtail      uint32       // p 的运行队列尾
    runq          [256]guintptr// p 的运行队列
    runnext       guintptr     // 下一个需要执行的 Goroutine
    gFree struct {
        gList
        n int32
    }
    ...
    palloc persistentAlloc // per-P to avoid mutex
    gcw gcWork
    ...
}

func schedinit() {
    _g_ := getg()            // 获取当前 Goroutine
    if raceenabled { ... }   // const raceenabled = false
    sched.maxmcount = 10000  // 设置最大线程数 10000；  Go 语言启动最大线程数为 10000
    tracebackinit()          // traceback 初始化
    moduledataverify()       // moduleData 验证
    stackinit()              // 堆栈初始化
    mallocinit()             // 内存分配初始化
    fastrandinit()           // 随机数模块初始化 
    mcommoninit(_g_.m)       // M 初始化
    cpuinit()                // 初始化 cpu 相关的配置信息
    alginit()                // algebra(代数模块)初始化
    modulesinit()            // 初始化活跃的 模块
    typelinksinit()          // 初始化类型链接
    itabsinit()              // 初始化 itabs
    msigsave(_g_.m)          // 将信号遮码保存到 主线程 m
    initSigmask = _g_.m.sigmask  // 初始化信号遮罩
    goargs()                 // 获得运行传参
    goenvs()                 // 获得环境信息
    parsedebugvars()         // 解析调试变量
    gcinit()                 // gc 初始化
    sched.lastpoll = uint64(nanotime())    // 初始化上次网络轮训时间
    procs := ncpu                          // P 数量设置成 cpu 数量
    if n, ok := atoi32(gogetenv("GOMAXPROCS")); ok && n > 0 {  // 如果有全局设置，则 P 数量设置为 GOMAXPROCS 
        procs = n                           
    }
    if procresize(procs) != nil {  // 调整 P 的数量（ P 初始化 )
        throw("unknown runnable goroutine during bootstrap")
    }
    ...
}

func mcommoninit(mp *m) {
    _g_ := getg()                             // 获得当前 Goroutine
    if _g_ != _g_.m.g0 {
        callers(1, mp.createstack[:])         // 如果 当前线程不是 M 的 g0, 创建堆栈
    }
    lock(&sched.lock)                         // 上锁
    if sched.mnext+1 < sched.mnext {          // 守卫: 判断 线程数是否溢出
        throw("runtime: thread ID overflow")
    }
    mp.id = sched.mnext                       // 给 m 设置 id (实际上是当前 m 的创建序列)
    sched.mnext++                             // mnext ++
    checkmcount()                             // 守卫: 判断 m 数量是否超过 限制（默认10000）

    // 初始化 m 随机数
    mp.fastrand[0] = uint32(int64Hash(uint64(mp.id), fastrandseed))
    mp.fastrand[1] = uint32(int64Hash(uint64(cputicks()), ^fastrandseed))
    if mp.fastrand[0]|mp.fastrand[1] == 0 {
        mp.fastrand[1] = 1
    }

    mpreinit(mp)                             // 为 m 初始化一个 专门处理信号的 g
    if mp.gsignal != nil {
        mp.gsignal.stackguard1 = mp.gsignal.stack.lo + _StackGuard
    }

    // 添加到 allm 中，从而当它刚保存到寄存器或本地线程存储时候 GC 不会释放 g.m  
    // 这里 allm 指向最后一个 m ，它用于将新的 m 的 allink 引导指向 上一个 m, 在将 allm 指向最新的 m； 这样所有的 m 就链接起来了
    mp.alllink = allm 
    atomicstorep(unsafe.Pointer(&allm), unsafe.Pointer(mp))

    unlock(&sched.lock)   // 解锁

    if iscgo || GOOS == "solaris" || GOOS == "illumos" || GOOS == "windows" {  // 若 GC 奔溃， 分配内存保存 TraceBack
        mp.cgoCallers = new(cgoCallers)
    }

func procresize(nprocs int32) *p {
    old := gomaxprocs                     // 获得Go启动后 P 的最大数量数量
    if old < 0 || nprocs <= 0 {           // 守卫: 判断 p 数量是否异常
        throw("procresize: invalid arg")
    }
    if trace.enabled {                    // 记录Trace事件
        traceGomaxprocs(nprocs)
    }
    now := nanotime()                     // 获取当前系统时间
    if sched.procresizetime != 0 {        // 记录 p 总用时: (当前时间 - 上次更改 p 的时间) * p 数量 + 上次记录的总用时
        sched.totaltime += int64(old) * (now - sched.procresizetime)
    }
    sched.procresizetime = now            // 记录最后一次更改 p 数量的时间

    // 该函数的主要部分 ：更新 p 的数量
    if nprocs > int32(len(allp)) {        // 若预期 p 的数量大于当前运行的 p 的数量 (allp 是个切片)
        lock(&allpLock)                   // 上锁
        if nprocs <= int32(cap(allp)) {   // 若预期 p 的数量 小于 allp 的容量(这里 allp 的容量大小是 程序执行至今 p 最多的时刻的 p 数量)
            allp = allp[:nprocs]          // 直接取切片(没有释放 多余 p 的空间)
        } else {                          // 若 历史最大 P 数量 小于 预期 P 数量 :
            nallp := make([]*p, nprocs)   // 按照预期 P 的数量创建空间
            copy(nallp, allp[:cap(allp)]) // 将 allp 直接复制到 新创空间中 (ps: 旧 P 已经初始化过)
            allp = nallp                  // allp 指针指向 新创建的空间
        }                                 
        unlock(&allpLock)                 // 解锁
    }
    // 遍历初始化需要新创建的 P
    for i := old; i < nprocs; i++ {       // 循环 需要创建的 P 的次数( 历史最大 P 数量 ～ 预期数量)
        pp := allp[i]                     
        if pp == nil {                    // 若 当前位置 nil，开辟空间创建 P 对象 (理论上应该都是 nil)
            pp = new(p)                   
        }
        pp.init(i)                        // 初始化新创建的 p, (使用序列 i 作为 p 的 ID)
        atomicstorep(unsafe.Pointer(&allp[i]), unsafe.Pointer(pp))  //  &allp[i] 指向 pp
    }

    // 调整 p 的工作状态
    _g_ := getg()   // 获取当前 Goroutine
    if _g_.m.p != 0 && _g_.m.p.ptr().id < nprocs {  
        // 若执行当前 G 的 M( 也可以说 线程; 个人还是倾向于 M 是 线程的指代/抽象) 存在 (m.p 是个 uintptr 默认值为 0),
        // 且其ID小于预期 P 的数量, 则继续使用当前的 P
        _g_.m.p.ptr().status = _Prunning            // 更改 当前 P 状态 为 Running
        _g_.m.p.ptr().mcache.prepareForSweep()      // 清空页面缓存
    } else {      // 当前 M 不存在 P 或者 P 的 id 已经大于当前 P 规定数量
        if _g_.m.p != 0 {                       // 当前 M 的 P 存在( 且序列已经超过预期 P 的个数 )
            if trace.enabled {                  // Trace 记录 并 停止 P 执行
                traceGoSched()
                traceProcStop(_g_.m.p.ptr())
            }
            _g_.m.p.ptr().m = 0     // 清楚 预释放 P 的 m指针 (不能让 停止的 p 还携带 m)
        }
        // M 的 P 不存在( 或者刚刚被清楚了 )
        _g_.m.p = 0              // 清空 当前 m 的 P 指针
        _g_.m.mcache = nil       // 清空当前 M 的 mcache (这个 mcache 实际上是从 P 中取到的)
        p := allp[0]             // 将 id = 0 的 p 交给 当前 M
        p.m = 0                  // 释放 这个 P 的 M 指针 ( id 为 0 的 P 不再为别的 M 服务了)
        p.status = _Pidle        // 重置 P 状态
        acquirep(p)              // 关联当前 P 和 M
        if trace.enabled {
            traceGoStart()       // 记录 Trace 事件
        }
    }

    for i := nprocs; i < old; i++ {  // 遍历多余的 P
        p := allp[i]
        p.destroy()        // 释放 P 的资源， 并将其转为 PDead
    }
}

func (pp *p) init(id int32) {
    pp.id = id                        // 赋予 id
    pp.status = _Pgcstop              // 初始化 status
    pp.sudogcache = pp.sudogbuf[:0]   // 初始化 sudog 队列的 cache 
    for i := range pp.deferpool {     // 初始化 defer 池
        pp.deferpool[i] = pp.deferpoolbuf[i][:0]
    }
    pp.wbBuf.reset()
    // 分配 cache 
    if pp.mcache == nil {      // 若当前 p 没有 cache空间
        if id == 0 {           // 且是第一个创建的
            if getg().m.mcache == nil {     // 守卫: 验证当前 M 的 cache 不为空
                throw("missing mcache?")
            }
            pp.mcache = getg().m.mcache     // 当前(最早创建的) M 的 cache (引导空间) 交给 最早创建的 P
        } else {
            pp.mcache = allocmcache()       // 分配新空间
        }
    }
    if raceenabled && pp.raceprocctx == 0 { ... }  // const raceenabled = false
}

func newproc(siz int32, fn *funcval) {             // siz 是参数长度， fn 是 go 执行的函数的引用指针
    argp := add(unsafe.Pointer(&fn), sys.PtrSize)  // 从 fn 的地址增加一个指针的长度，从而获取第一个参数的地址
    gp := getg()                                   // 获得当前 G
    pc := getcallerpc()                            // 获得 pc 寄存器
    systemstack(func() {                           // 使用系统堆栈调用下面的函数
        newproc1(fn, argp, siz, gp, pc)            // 创建 G 
    })
}

func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerpc uintptr) {
    _g_ := getg()             // 获得当前 G
    if fn == nil {            // 守卫: 判断 fn 是否是 nil
        _g_.m.throwing = -1
        throw("go of nil func value")
    }
    acquirem()      // _g_ := getg(); _g_.m.locks++;  禁止当前 m 被抢占因为它可以在一个局部变量中保存 p
    siz := narg     
    siz = (siz + 7) &^ 7  // 8字节对齐。

    if siz >= _StackMin-4*sys.RegSize-sys.RegSize {    // 守卫： 穿参过大，超过内存控制范围
        throw("newproc: function arguments too large for new goroutine")
    }

    _p_ := _g_.m.p.ptr                    // 当前 P
    newg := gfget(_p_)                    // 通过 P 获得一个新 G
    if newg == nil {                      // 如果 新 G 是空的
        newg = malg(_StackMin)            // 创建一个拥有 _StackMin 大小的栈的 g     
        casgstatus(newg, _Gidle, _Gdead)  // 将新创建的 g 从 _Gidle 更新为 _Gdead 状态
        allgadd(newg)                     // 将 Gdead 状态的 g 添加到 allg，这样 GC 不会扫描未初始化的栈 
    }
    if newg.stack.hi == 0 {               // 守卫: 判断 newg 拥有的栈大小是否没有初始化
        throw("newproc1: newg missing stack")
    }
    if readgstatus(newg) != _Gdead {      // 守卫: 判断 newg 的状态 是否是 _Gdead
        throw("newproc1: new g is not Gdead")
    }
    // 计算运行空间大小，对齐
    totalSize := 4*sys.RegSize + uintptr(siz) + sys.MinFrameSize // 计算程序需要的运行空间
    totalSize += -totalSize & (sys.SpAlign - 1)                  // 对齐到 spAlign

    sp := newg.stack.hi - totalSize                              // 确定 sp 入栈位置
    spArg := sp                                                  // 确定 参数 入栈位置
    if usesLR {
        *(*uintptr)(unsafe.Pointer(sp)) = 0
        prepGoExitFrame(sp)
        spArg += sys.MinFrameSize
    }
    if narg > 0 {  // 存在传参
        memmove(unsafe.Pointer(spArg), argp, uintptr(narg))  // 将传参的内容，复制到 新 G 的执行栈
        if writeBarrier.needed && !_g_.m.curg.gcscandone {   // 如果当前写屏蔽开启, 并且当前 G 的堆栈尚未被 GC 扫描
            f := findfunc(fn.fn)                             // 通过原方法的指针(开辟新的空间)构建方法对象(funcInfo)
            stkmap := (*stackmap)(funcdata(f, _FUNCDATA_ArgsPointerMaps))  // 将新创建的方法对象指针封装成栈映射对象(stackmap)
            if stkmap.nbit > 0 {                             // 若栈映射对象的索引大于 0
                bv := stackmapdata(stkmap, 0)                // 获取堆栈第0位的位向量
                bulkBarrierBitmap(spArg, spArg, uintptr(bv.n)*sys.PtrSize, 0, bv.bytedata)  // 重新将参数复制到 G 的执行栈
            }
        }
    }
    // 清理、创建并初始化的 g 的运行现场
    memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))  // 清空 新创建的 G 的运行现场
    newg.sched.sp = sp                                // 初始化 运行现场的 sp 偏移量
    newg.stktopsp = sp                                // 初始化 sp 堆顶偏移量
    newg.sched.pc = funcPC(goexit) + sys.PCQuantum    // 初始化 pc 偏移量
    newg.sched.g = guintptr(unsafe.Pointer(newg))     // 初始化 调度信息的 g (newg 获取指针 给 sched.g)
    gostartcallfn(&newg.sched, fn)                    // 根据 fn, 系统信息 调整 sched 的 sp, pc, ctxt
    // 初始化 newg 的状态
    newg.gopc = callerpc                              // 新 G 继承 当前 G 的 pc
    newg.ancestors = saveAncestors(callergp)          // 当前 G 封装成 []ancestorsInfo 赋值给 ancestors (祖先 g 列表)
    newg.startpc = fn.fn                              // 当前 G 的初始 PC 指向 fn的地址
    if _g_.m.curg != nil {                            // 若当前 M 运行的 G 不为空:
        newg.labels = _g_.m.curg.labels               // 新 G 继承 当前 M 运行的 G 的 标签
    }
    if isSystemGoroutine(newg, false) {               // 若 新创建的 g 是 System Goroutine 运行现场的系统g统计 + 1 
        atomic.Xadd(&sched.ngsys, +1)
    }
    casgstatus(newg, _Gdead, _Grunnable)              // 完成 newg 初始化， 转为 _Grunable 状态
    // 分配 goid 
    if _p_.goidcache == _p_.goidcacheend {
        _p_.goidcache = atomic.Xadd64(&sched.goidgen, _GoidCacheBatch)
        _p_.goidcache -= _GoidCacheBatch - 1
        _p_.goidcacheend = _p_.goidcache + _GoidCacheBatch
    }
    newg.goid = int64(_p_.goidcache)
    _p_.goidcache++
    if raceenabled { ... }                       // const raceenabled = false 
    if trace.enabled {                           // 记录 Trace 事件
        traceGoCreate(newg, newg.startpc)
    }
    runqput(_p_, newg, true)                     // 将这里新创建的 g 放入 p 的本地队列或直接放入全局队列
    //  如果有空闲的 P、且 spinning 的 M 数量为 0，且主 goroutine 已经开始运行，则进行唤醒 p
    if atomic.Load(&sched.npidle) != 0 && atomic.Load(&sched.nmspinning) == 0 && mainStarted {
        wakep()
    }
    releasem(_g_.m)  // 为 M 解锁 (回应 函数开头防止 M 被抢占上锁)
}