深入Go调度器：GMP模型源码解析与实践

type g struct {
    // 栈参数 - 描述实际栈内存：[stack.lo, stack.hi)
    // stackguard0 是Go栈增长序言中比较的栈指针
    // 通常是 stack.lo+StackGuard，但可以是 StackPreempt 来触发抢占
    // stackguard1 是C栈增长序言中比较的栈指针
    // 在g0和gsignal栈上是 stack.lo+StackGuard
    // 在其他goroutine栈上是 ~0，触发调用 morestackc（并崩溃）
    stack       stack   // 栈信息，offset known to runtime/cgo
    stackguard0 uintptr // 栈保护边界，offset known to liblink
    stackguard1 uintptr // 栈保护边界，offset known to liblink

    _panic       *_panic // 最内层panic - offset known to liblink
    _defer       *_defer // 最内层defer
    m            *m      // 当前m；offset known to arm liblink
    sched        gobuf   // 调度上下文
    syscallsp    uintptr // 如果status==Gsyscall，syscallsp = sched.sp 用于gc
    syscallpc    uintptr // 如果status==Gsyscall，syscallpc = sched.pc 用于gc
    stktopsp     uintptr // 栈顶期望的sp，用于traceback检查
    param        unsafe.Pointer // 唤醒时传递的参数
    atomicstatus uint32         // 原子状态
    stackLock    uint32         // sigprof/scang锁；TODO: 折叠到atomicstatus中
    goid         int64          // goroutine ID
    schedlink    guintptr       // 调度链表
    waitsince    int64          // g变为阻塞时的大致时间
    waitreason   waitReason     // 如果status==Gwaiting的等待原因

    preempt       bool // 抢占信号，复制stackguard0 = stackpreempt
    preemptStop   bool // 抢占时转换到_Gpreempted；否则，只是取消调度
    preemptShrink bool // 在同步安全点收缩栈

    // asyncSafePoint 在g停在异步安全点时设置
    // 这意味着栈上有没有精确指针信息的帧
    asyncSafePoint bool

    paniconfault bool // 在意外故障地址上panic（而不是崩溃）
    gcscandone   bool // g已扫描栈；受status中的_Gscan位保护
    throwsplit   bool // 不得分割栈
    
    // activeStackChans 表示有未锁定的channel指向此goroutine的栈
    // 如果为true，栈复制需要获取channel锁来保护栈的这些区域
    activeStackChans bool
    
    // parkingOnChan 表示goroutine即将在chansend或chanrecv上park
    // 用于标记栈收缩的不安全点。这是一个布尔值，但原子更新
    parkingOnChan uint8

    raceignore     int8     // 忽略竞态检测事件
    sysblocktraced bool     // StartTrace已为此goroutine发出EvGoInSyscall
    sysexitticks   int64    // syscall返回时的cputicks（用于跟踪）
    traceseq       uint64   // 跟踪事件序列器
    tracelastp     puintptr // 为此goroutine发出事件的最后一个P
    lockedm        muintptr // 锁定的M
    sig            uint32   // 信号
    writebuf       []byte   // 写缓冲区
    sigcode0       uintptr  // 信号代码0
    sigcode1       uintptr  // 信号代码1
    sigpc          uintptr  // 信号PC
    gopc           uintptr  // 创建此goroutine的go语句的pc
    ancestors      *[]ancestorInfo // 创建此goroutine的祖先goroutine信息（仅在debug.tracebackancestors时使用）
    startpc        uintptr         // goroutine函数的pc
    racectx        uintptr         // 竞态上下文
    waiting        *sudog          // 此g等待的sudog结构（具有有效elem ptr）；按锁顺序
    cgoCtxt        []uintptr       // cgo回溯上下文
    labels         unsafe.Pointer  // 分析器标签
    timer          *timer          // time.Sleep的缓存计时器
    selectDone     uint32          // 我们是否参与select并且有人赢得了竞争？

    // Per-G GC状态
    // gcAssistBytes 是此G的GC辅助信用，以分配的字节为单位
    // 如果为正，则G有信用分配gcAssistBytes字节而无需辅助
    // 如果为负，则G必须通过执行扫描工作来纠正这一点
    // 我们以字节为单位跟踪这一点，以便在malloc热路径中快速更新和检查债务
    // 辅助比率决定了这如何对应于扫描工作债务
    gcAssistBytes int64
}

type m struct {
    g0      *g     // 每个M都有一个自己的g0，用于调度和系统调用时的栈切换
    curg    *g     // 当前正在执行的Goroutine
    // ... 其他字段
}

type p struct {
    id          int32       // P的唯一标识
    status      uint32      // P的状态，如空闲、运行中、系统调用中等
    link        puintptr    // 用于将P链接到全局P队列中
    schedtick   uint32      // 每次调度时递增的计数器
    syscalltick uint32      // 每次系统调用时递增的计数器
    m           muintptr    // 指向当前绑定的M

    // 可执行的Goroutine队列，支持无锁访问
    runqhead    uint32
    runqtail    uint32
    runq        [256]guintptr
    runnext     guintptr    // 下一个优先执行的Goroutine
    // ...
}

type schedt struct {
    // 全局Goroutine队列，链表结构，长度无限制
    runq     gQueue
    runqsize int32      // 全局队列长度
    // ...
}

sequenceDiagram
    participant OS as 操作系统
    participant RT as runtime·rt0_go
    participant SCHED as schedinit
    participant P as Processor
    participant M as Machine
    participant G as Goroutine

    OS->>RT: 程序启动
    RT->>RT: 初始化g0和m0
    RT->>SCHED: 调用schedinit()
    
    SCHED->>SCHED: 设置GOMAXPROCS
    SCHED->>P: 创建P数组(allp)
    loop 为每个P初始化
        SCHED->>P: 初始化P结构
        P->>P: 设置本地队列
        P->>P: 初始化mcache
    end
    
    SCHED->>M: 初始化m0
    M->>P: 绑定P[0]
    
    RT->>RT: 创建main goroutine
    RT->>G: newproc(main.main)
    G->>P: 加入本地队列
    
    RT->>M: 调用mstart()
    M->>M: 进入调度循环

sequenceDiagram
    participant USER as 用户代码
    participant RT as runtime
    participant P as 当前P
    participant G as 新Goroutine
    participant SCHED as 调度器

    USER->>RT: go func()
    RT->>RT: newproc()
    RT->>G: 分配g结构体
    G->>G: 初始化栈和上下文
    G->>G: 设置状态为_Grunnable
    
    RT->>P: runqput(g)
    alt P本地队列未满
        P->>P: 加入本地队列尾部
    else P本地队列已满
        P->>SCHED: runqputslow()
        SCHED->>SCHED: 将一半G移到全局队列
        SCHED->>P: 新G加入本地队列
    end
    
    alt 有空闲P
        RT->>SCHED: wakep()
        SCHED->>SCHED: 唤醒或创建M
    end

sequenceDiagram
    participant M as Machine
    participant P as Processor
    participant G as Goroutine
    participant SCHED as 调度器
    participant GQ as 全局队列

    M->>M: schedule()
    
    loop 调度循环
        M->>P: 检查本地队列
        alt 本地队列有G
            P->>G: 获取下一个G
        else 本地队列为空
            M->>SCHED: findRunnable()
            
            alt 全局队列有G
                SCHED->>GQ: 从全局队列获取
                GQ->>G: 返回G
            else 尝试工作窃取
                SCHED->>SCHED: stealWork()
                loop 遍历其他P
                    SCHED->>P: runqsteal()
                    alt 窃取成功
                        P->>G: 返回窃取的G
                    end
                end
            else 检查网络轮询器
                SCHED->>SCHED: netpoll()
                alt 有就绪的网络G
                    SCHED->>G: 返回网络G
                end
            end
        end
        
        M->>G: execute(g)
        G->>G: 执行用户代码
        
        alt G正常结束
            G->>M: goexit()
            M->>G: 清理G结构
        else G被抢占
            G->>M: 保存上下文
            M->>P: 将G放回队列
        else G阻塞
            G->>M: gopark()
            M->>G: 设置状态为_Gwaiting
        end
    end

sequenceDiagram
    participant M1 as 空闲M
    participant P1 as 空闲P
    participant M2 as 忙碌M
    participant P2 as 忙碌P
    participant G as Goroutine

    M1->>M1: findRunnable()
    M1->>P1: 检查本地队列(空)
    M1->>M1: 检查全局队列(空)
    
    M1->>M1: stealWork()
    loop 遍历所有P
        M1->>P2: runqsteal(P2)
        P2->>P2: 检查本地队列
        alt P2队列有多个G
            P2->>G: 从队列头部取一半
            P2->>P1: 返回窃取的G
            P1->>P1: 将G加入本地队列
        else P2队列只有1个G
            P2->>M1: 窃取失败
        end
    end
    
    alt 窃取成功
        M1->>G: execute(g)
    else 窃取失败
        M1->>M1: 进入休眠状态
    end

sequenceDiagram
    participant SYSMON as sysmon
    participant M as Machine
    participant P as Processor
    participant G as Goroutine
    participant GC as 垃圾收集器

    SYSMON->>SYSMON: 启动系统监控线程
    
    loop 监控循环
        SYSMON->>SYSMON: 休眠一段时间
        
        SYSMON->>SYSMON: retake()
        loop 检查所有P
            SYSMON->>P: 检查P状态
            
            alt P在系统调用中
                SYSMON->>P: 检查系统调用时间
                alt 超过阈值
                    SYSMON->>P: handoffp()
                    P->>M: 解绑M和P
                    SYSMON->>SYSMON: 寻找新M接管P
                end
            else P在运行中
                SYSMON->>G: 检查G运行时间
                alt 超过抢占阈值
                    SYSMON->>G: preemptone()
                    G->>G: 设置抢占标志
                end
            end
        end
        
        SYSMON->>GC: 检查是否需要GC
        alt 满足GC条件
            SYSMON->>GC: 触发GC
        end
        
        SYSMON->>SYSMON: 检查网络轮询器
        SYSMON->>SYSMON: 清理死锁检测
    end

func newproc(fn *funcval) {
    gp := getg()
    pc := sys.GetCallerPC()
    systemstack(func() {
        newg := newproc1(fn, gp, pc, false, waitReasonZero)

        pp := getg().m.p.ptr()
        runqput(pp, newg, true)

        if mainStarted {
            wakep()
        }
    })
}

TEXT runtime·systemstack(SB), NOSPLIT, $0-4
    MOVL    fn+0(FP), DI    // DI = fn
    get_tls(CX)
    MOVL    g(CX), AX    // AX = g
    MOVL    g_m(AX), BX    // BX = m

    CMPL    AX, m_gsignal(BX)
    JEQ    noswitch

    MOVL    m_g0(BX), DX    // DX = g0
    CMPL    AX, DX
    JEQ    noswitch

    CMPL    AX, m_curg(BX)
    JNE    bad

    // 切换栈
    // 在g->sched中保存我们的状态。如果扫描G栈，则假装为systemstack_switch
    CALL    gosave_systemstack_switch<>(SB)

    // 切换到g0
    get_tls(CX)
    MOVL    DX, g(CX)
    MOVL    (g_sched+gobuf_sp)(DX), BX
    MOVL    BX, SP

    // 调用目标函数
    MOVL    DI, DX
    MOVL    0(DI), DI
    CALL    DI

    // 切换回g
    get_tls(CX)
    MOVL    g(CX), AX
    MOVL    g_m(AX), BX
    MOVL    m_curg(BX), AX
    MOVL    AX, g(CX)
    MOVL    (g_sched+gobuf_sp)(AX), SP
    MOVL    $0, (g_sched+gobuf_sp)(AX)
    RET

noswitch:
    // 已经在系统栈上；尾调用函数
    // 在这里使用尾调用清理回溯，因为我们不会在中间systemstack处停止
    MOVL    DI, DX
    MOVL    0(DI), DI
    JMP    DI

bad:
    // 错误：g不是gsignal，不是g0，不是curg。它是什么？
    // 从链接器nosplit分析中隐藏调用
    MOVL    $runtime·badsystemstack(SB), AX
    CALL    AX
    INT    $3

type funcval struct {
    fn uintptr
    // 可变大小，fn特定的数据在这里
}

// 调用目标函数
MOVQ    DI, DX
MOVQ    0(DI), DI
CALL    DI

func newproc1(fn *funcval, callergp *g, callerpc uintptr, parked bool, waitreason waitReason) *g {

    mp := acquirem() // 禁用抢占，因为我们在本地变量中持有M和P
    pp := mp.p.ptr()
    newg := gfget(pp)
    if newg == nil {
        newg = malg(stackMin)
        casgstatus(newg, _Gidle, _Gdead)
        allgadd(newg) // 以g->status为Gdead发布，这样GC扫描器不会查看未初始化的栈
    }

    totalSize := uintptr(4*goarch.PtrSize + sys.MinFrameSize) // 额外空间以防读取稍微超出帧
    totalSize = alignUp(totalSize, sys.StackAlign)
    sp := newg.stack.hi - totalSize

    memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
    newg.sched.sp = sp
    newg.stktopsp = sp
    newg.sched.pc = abi.FuncPCABI0(goexit) + sys.PCQuantum // +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
    newg.runningCleanups.Store(false)
    
    gcController.addScannableStack(pp, int64(newg.stack.hi-newg.stack.lo))

    var status uint32 = _Grunnable
    if parked {
        status = _Gwaiting
        newg.waitreason = waitreason
    }
    if pp.goidcache == pp.goidcacheend {
        pp.goidcache = sched.goidgen.Add(_GoidCacheBatch)
        pp.goidcache -= _GoidCacheBatch - 1
        pp.goidcacheend = pp.goidcache + _GoidCacheBatch
    }
    newg.goid = pp.goidcache
    casgstatus(newg, _Gdead, status)
    pp.goidcache++

    pp.goroutinesCreated++
    releasem(mp)

    return newg
}

func gostartcallfn(gobuf *gobuf, fv *funcval) {
    var fn unsafe.Pointer
    if fv != nil {
        fn = unsafe.Pointer(fv.fn)
    } else {
        fn = unsafe.Pointer(abi.FuncPCABIInternal(nilfunc))
    }
    gostartcall(gobuf, fn, unsafe.Pointer(fv))
}

func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
    sp := buf.sp
    sp -= goarch.PtrSize
    *(*uintptr)(unsafe.Pointer(sp)) = buf.pc
    buf.sp = sp
    buf.pc = uintptr(fn)
    buf.ctxt = ctxt
}

func acquirem() *m {
    gp := getg()
    gp.m.locks++
    return gp.m
}

func releasem(mp *m) {
    gp := getg()
    mp.locks--
    if mp.locks == 0 && gp.preempt {
        // 如果我们在newstack中清除了抢占请求，则恢复它
        gp.stackguard0 = stackPreempt
    }
}

func runqput(pp *p, gp *g, next bool) {
    if randomizeScheduler && next && randn(2) == 0 {
        next = false
    }

    if next {
    retryNext:
        oldnext := pp.runnext
        if !pp.runnext.cas(oldnext, guintptr(unsafe.Pointer(gp))) {
            goto retryNext
        }
        if oldnext == 0 {
            return
        }
        // 将旧的runnext踢到常规运行队列
        gp = oldnext.ptr()
    }

retry:
    h := atomic.LoadAcq(&pp.runqhead) // load-acquire，与消费者同步
    t := pp.runqtail
    if t-h < uint32(len(pp.runq)) {
        pp.runq[t%uint32(len(pp.runq))].set(gp)
        atomic.StoreRel(&pp.runqtail, t+1) // store-release，使项目可供消费
        return
    }
    if runqputslow(pp, gp, h, t) {
        return
    }
    // 队列未满，现在上面的put必须成功
    goto retry
}

func wakep() {
    // 对自旋线程保守，只有在不存在时才启动一个
    if sched.nmspinning.Load() != 0 || !sched.nmspinning.CompareAndSwap(0, 1) {
        return
    }

    // 禁用抢占直到pp的所有权转移到startm中的下一个M
    // 否则这里的抢占会让pp卡在等待进入_Pgcstop
    mp := acquirem()

    var pp *p
    lock(&sched.lock)
    pp, _ = pidlegetSpinning(0)
    if pp == nil {
        if sched.nmspinning.Add(-1) < 0 {
            throw("wakep: negative nmspinning")
        }
        unlock(&sched.lock)
        releasem(mp)
        return
    }
    unlock(&sched.lock)

    startm(pp, true, false)
    releasem(mp)
}

func startm(pp *p, spinning, lockheld bool) {
    mp := acquirem()
    if !lockheld {
        lock(&sched.lock)
    }

    nmp := mget()
    if nmp == nil {
        // 没有可用的M，我们必须释放sched.lock并调用newm
        // 但是，我们已经拥有一个要分配给M的P
        id := mReserveID()
        unlock(&sched.lock)

        var fn func()
        if spinning {
            // 调用者递增了nmspinning，所以在新M中设置m.spinning
            fn = mspinning
        }
        newm(fn, pp, id)

        if lockheld {
            lock(&sched.lock)
        }
        releasem(mp)
        return
    }
    
    if !lockheld {
        unlock(&sched.lock)
    }
    if nmp.spinning {
        throw("startm: m is spinning")
    }
    if nmp.nextp != 0 {
        throw("startm: m has p")
    }
    if spinning && !runqempty(pp) {
        throw("startm: p has runnable gs")
    }
    // 调用者递增了nmspinning，所以在新M中设置m.spinning
    nmp.spinning = spinning
    nmp.nextp.set(pp)
    notewakeup(&nmp.park)
    releasem(mp)
}

func newm(fn func(), pp *p, id int64) {
    acquirem()

    mp := allocm(pp, fn, id)
    mp.nextp.set(pp)
    mp.sigmask = initSigmask

    newm1(mp)
    releasem(getg().m)
}

func newosproc(mp *m) {
    stk := unsafe.Pointer(mp.g0.stack.hi)

    var oset sigset
    sigprocmask(_SIG_SETMASK, &sigset_all, &oset)
    ret := retryOnEAGAIN(func() int32 {
        r := clone(cloneFlags, stk, unsafe.Pointer(mp), unsafe.Pointer(mp.g0), unsafe.Pointer(abi.FuncPCABI0(mstart)))

        if r >= 0 {
            return 0
        }
        return -r
    })
    sigprocmask(_SIG_SETMASK, &oset, nil)
}

func mstart0() {
    gp := getg()
    
    gp.stackguard0 = gp.stack.lo + stackGuard
    gp.stackguard1 = gp.stackguard0

    mstart1()
}

func mstart1() {
    gp := getg()

    gp.sched.g = guintptr(unsafe.Pointer(gp))
    gp.sched.pc = sys.GetCallerPC()
    gp.sched.sp = sys.GetCallerSP()

    asminit()
    minit()

    if fn := gp.m.mstartfn; fn != nil {
        fn()
    }

    if gp.m != &m0 {
        acquirep(gp.m.nextp.ptr())
        gp.m.nextp = 0
    }
    schedule()
}

func schedule() {
    mp := getg().m

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

    gp, inheritTime, tryWakeP := findRunnable() // 阻塞直到工作可用

    mp.clearAllpSnapshot()

    if mp.spinning {
        resetspinning()
    }

    if tryWakeP {
        wakep()
    }

    if gp.lockedm != 0 {
        // 将自己的p交给锁定的m，然后阻塞等待新的p
        startlockedm(gp)
        goto top
    }

    execute(gp, inheritTime)
}

func findRunnable() (gp *g, inheritTime, tryWakeP bool) {
    mp := getg().m

top:
    mp.clearAllpSnapshot()
    pp := mp.p.ptr()

    now, pollUntil, _ := pp.timers.check(0, nil)

    // 1. 如果gcBlackenEnabled=1，表明在gc过程中，获取一个gc worker去执行
    if gcBlackenEnabled != 0 {
        gp, tnow := gcController.findRunnableGCWorker(pp, now)
        if gp != nil {
            return gp, false, true
        }
        now = tnow
    }

    // 2. 每隔61次，执行一次全局待运行的g
    if pp.schedtick%61 == 0 && !sched.runq.empty() {
        lock(&sched.lock)
        gp := globrunqget()
        unlock(&sched.lock)
        if gp != nil {
            return gp, false, false
        }
    }

    // 3. 从p.runnext或者p.runq里面获取一个可执行g
    if gp, inheritTime := runqget(pp); gp != nil {
        return gp, inheritTime, false
    }

    // 4. 从全局sched.runq里面获取一批g，放入到p的队列
    if !sched.runq.empty() {
        lock(&sched.lock)
        gp, q := globrunqgetbatch(int32(len(pp.runq)) / 2)
        unlock(&sched.lock)
        if gp != nil {
            if runqputbatch(pp, &q); !q.empty() {
                throw("Couldn't put Gs into empty local runq")
            }
            return gp, false, false
        }
    }

    // 5. 非阻塞的方式获取网络read的相关g
    if netpollinited() && netpollAnyWaiters() && sched.lastpoll.Load() != 0 && sched.pollingNet.Swap(1) == 0 {
        list, delta := netpoll(0)
        sched.pollingNet.Store(0)
        if !list.empty() {
            gp := list.pop()
            injectglist(&list)
            netpollAdjustWaiters(delta)
            trace := traceAcquire()
            casgstatus(gp, _Gwaiting, _Grunnable)
            if trace.ok() {
                trace.GoUnpark(gp, 0)
                traceRelease(trace)
            }
            return gp, false, false
        }
    }

    // 6. 通过stealwork去其他p获取一批g列表
    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 {
            return gp, inheritTime, false
        }
        if newWork {
            goto top
        }

        now = tnow
        if w != 0 && (pollUntil == 0 || w < pollUntil) {
            pollUntil = w
        }
    }

    // 7. 再检查下gc任务
    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)
            return gp, false, false
        }
        gcController.removeIdleMarkWorker()
    }

    // 8. 再去全局sched.runq里面获取可执行的g
    lock(&sched.lock)
    if !sched.runq.empty() {
        gp, q := globrunqgetbatch(int32(len(pp.runq)) / 2)
        unlock(&sched.lock)
        if gp == nil {
            throw("global runq empty with non-zero runqsize")
        }
        if runqputbatch(pp, &q); !q.empty() {
            throw("Couldn't put Gs into empty local runq")
        }
        return gp, false, false
    }

    // 9. 将p放入idle列表，然后调用netpoll等待网络相关的g ready
    now = pidleput(pp, now)
    unlock(&sched.lock)

    if netpollinited() && (netpollAnyWaiters() || pollUntil != 0) && sched.lastpoll.Swap(0) != 0 {
        list, delta := netpoll(delay) // 阻塞直到新工作可用
        now = nanotime()
        sched.pollUntil.Store(0)
        sched.lastpoll.Store(now)

        lock(&sched.lock)
        pp, _ := pidleget(now)
        unlock(&sched.lock)
        if pp == nil {
            injectglist(&list)
            netpollAdjustWaiters(delta)
        } else {
            acquirep(pp)
            if !list.empty() {
                gp := list.pop()
                injectglist(&list)
                netpollAdjustWaiters(delta)
                casgstatus(gp, _Gwaiting, _Grunnable)
                return gp, false, false
            }
            goto top
        }
    }
    stopm()
    goto top
}

// runqget 从本地队列获取goroutine (runnext > 本地队列)
func runqget(pp *p) (gp *g, inheritTime bool) {
    // 优先从 runnext 获取
    for {
        old := pp.runnext
        if old == 0 { break }
        if pp.runnext.cas(old, 0) {
            return old.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) {
            return gp, false
        }
    }
}

// stealWork 实现负载均衡的工作窃取机制
func stealWork(now int64) (gp *g, inheritTime bool, rnow, pollUntil int64, newWork bool) {
    pp := getg().m.p.ptr()
    randn := fastrandn(uint32(gomaxprocs))
    
    const stealTries = 4
    for i := 0; i < stealTries; i++ {
        stealTimersOrRunNextG := i == stealTries-1
        
        // 随机遍历所有P
        for j := 0; j < gomaxprocs; j++ {
            p2 := allp[(randn+uint32(j))%uint32(gomaxprocs)]
            if pp == p2 {
                continue
            }
            
            // 窃取goroutine
            if gp := runqsteal(pp, p2, stealTimersOrRunNextG); gp != nil {
                return gp, false, now, pollUntil, false
            }
            
            // 窃取定时器任务
            if stealTimersOrRunNextG {
                tnow, w, ran := pp.timers.steal(p2, now)
                now = tnow
                if w != 0 && (pollUntil == 0 || w < pollUntil) {
                    pollUntil = w
                }
                if ran {
                    if gp, inheritTime := runqget(pp); gp != nil {
                        return gp, inheritTime, now, pollUntil, false
                    }
                }
            }
        }
    }
    
    return nil, false, now, pollUntil, false
}

// runqsteal 从目标P窃取一半的goroutine
func runqsteal(pp, p2 *p, stealRunNext bool) *g {
    t := pp.runqtail
    n := runqgrab(p2, &pp.runq, t, stealRunNext)
    if n == 0 {
        return nil
    }
    
    n--
    gp := pp.runq[(t+n)%uint32(len(pp.runq))].ptr()
    if n == 0 {
        return gp
    }
    
    h := atomic.LoadAcq(&pp.runqhead)
    if t-h+n >= uint32(len(pp.runq)) {
        return gp
    }
    
    atomic.StoreRel(&pp.runqtail, t+n)
    return gp
}

func execute(gp *g, inheritTime bool) {
    mp := getg().m

    // 设置当前执行的G
    mp.curg = gp
    gp.m = mp
    gp.syncSafePoint = false // 清除标志，可能由morestack设置
    casgstatus(gp, _Grunnable, _Grunning)
    gp.waitsince = 0
    gp.preempt = false
    gp.stackguard0 = gp.stack.lo + stackGuard
    if !inheritTime {
        mp.p.ptr().schedtick++
    }

    gogo(&gp.sched)
}

TEXT runtime·gogo(SB), NOSPLIT, $0-8
    MOVQ    buf+0(FP), BX        // gobuf
    MOVQ    gobuf_g(BX), DX
    MOVQ    0(DX), CX        // 确保g != nil
    JMP    gogo<>(SB)

TEXT gogo<>(SB), NOSPLIT, $0
    get_tls(CX)
    MOVQ    DX, g(CX)
    MOVQ    DX, R14        // 设置g寄存器
    MOVQ    gobuf_sp(BX), SP    // 恢复SP
    MOVQ    gobuf_ctxt(BX), DX
    MOVQ    gobuf_bp(BX), BP
    MOVQ    $0, gobuf_sp(BX)    // 清除以帮助垃圾回收器
    MOVQ    $0, gobuf_ctxt(BX)
    MOVQ    $0, gobuf_bp(BX)
    MOVQ    gobuf_pc(BX), BX
    JMP    BX

func goexit0(gp *g) {
    gdestroy(gp)
    schedule()
}

func gdestroy(gp *g) {
    mp := getg().m
    pp := mp.p.ptr()

    casgstatus(gp, _Grunning, _Gdead)
    gcController.addScannableStack(pp, -int64(gp.stack.hi-gp.stack.lo))

    gp.m = nil
    locked := gp.lockedm != 0
    gp.lockedm = 0
    mp.lockedg = 0
    gp.preemptStop = false
    gp.paniconfault = false
    gp._defer = nil // 应该已经为true，但以防万一
    gp._panic = nil // Goexit期间panic的非nil。指向栈分配的数据
    gp.writebuf = nil
    gp.waitreason = waitReasonZero
    gp.param = nil
    gp.labels = nil
    gp.timer = nil

    if gcBlackenEnabled != 0 && gp.gcAssistBytes > 0 {
        assistWorkPerByte := gcController.assistWorkPerByte.Load()
        scanCredit := int64(assistWorkPerByte * float64(gp.gcAssistBytes))
        gcController.bgScanCredit.Add(scanCredit)
        gp.gcAssistBytes = 0
    }

    dropg()
    gfput(pp, gp)
}

func gfput(pp *p, gp *g) {
    if readgstatus(gp) != _Gdead {
        throw("gfput: bad status (not Gdead)")
    }

    stksize := gp.stack.hi - gp.stack.lo

    if stksize != uintptr(startingStackSize) {
        // 非标准栈大小 - 释放它
        stackfree(gp.stack)
        gp.stack.lo = 0
        gp.stack.hi = 0
        gp.stackguard0 = 0
    }

    pp.gFree.push(gp)
    if pp.gFree.size >= 64 {
        var (
            stackQ   gQueue
            noStackQ gQueue
        )
        for pp.gFree.size >= 32 {
            gp := pp.gFree.pop()
            if gp.stack.lo == 0 {
                noStackQ.push(gp)
            } else {
                stackQ.push(gp)
            }
        }
        lock(&sched.gFree.lock)
        sched.gFree.noStack.pushAll(noStackQ)
        sched.gFree.stack.pushAll(stackQ)
        unlock(&sched.gFree.lock)
    }
}