1
type g struct {
2
    stack       stack      // 栈的边界 [lo, hi)
3
    stackguard0 uintptr    // 栈溢出检查，也用于抢占信号
4
    sched       gobuf      // 调度上下文（保存的寄存器）
5
    goid        int64      // goroutine ID
6
    m           *m         // 当前绑定的 M
7
    atomicstatus uint32    // goroutine 状态（原子操作）
8
    preempt     bool       // 抢占信号
9
    preemptStop bool       // 抢占时将状态修改为 _Gpreempted
10
    preemptShrink bool     // 在同步安全点收缩栈
11
    _panic      *_panic    // 最内侧的 panic
12
    _defer      *_defer    // 最内侧的 defer
13
    waiting     *sudog     // 等待队列
14
    ...
15
}
16

17
type gobuf struct {
18
    sp   uintptr  // 保存的栈指针
19
    pc   uintptr  // 保存的程序计数器
20
    g    guintptr // 指向 g 的指针
21
    ret  uintptr  // 返回值
22
    bp   uintptr  // 保存的基址指针（帧指针）
23
}

1
type m struct {
2
    g0       *g        // 调度栈 goroutine，执行调度代码时使用
3
    curg     *g        // 当前运行的用户 goroutine
4
    p        puintptr  // 当前绑定的 P
5
    nextp    puintptr  // 唤醒 M 时要绑定的 P
6
    oldp     puintptr  // 系统调用前的 P，用于快速恢复
7
    spinning bool      // 是否正在自旋找工作
8
    ...
9
}
10

11
type p struct {
12
    id        int32
13
    status    uint32     // P 的状态
14
    m         muintptr   // 反向指向绑定的 M
15
    runqhead  uint32     // 本地队列头
16
    runqtail  uint32     // 本地队列尾
17
    runq      [256]guintptr  // 本地运行队列（环形数组）
18
    runnext   guintptr   // 下一个要运行的 G（最高优先级）
19
    gFree     *g         // 空闲 G 缓存链表
20
    ...
21
}

1
func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
2
    sp := buf.sp
3
    sp -= sys.PtrSize                    // 栈腾出一个指针的空间
4
    *(*uintptr)(unsafe.Pointer(sp)) = buf.pc  // 把 goexit 的地址压入栈
5
    buf.sp = sp
6
    buf.pc = uintptr(fn)                 // pc 设为 fn 的地址
7
}

1
type stack struct {
2
    lo uintptr  // 栈底，低地址
3
    hi uintptr  // 栈顶，高地址
4
}

1
func schedule() {
2
    _g_ := getg()
3
    var gp *g
4
    var inheritTime bool
5

6
    // 每隔 61 次调度，检查全局队列，保证公平
7
    if _g_.m.p.ptr().schedtick%61 == 0 && sched.runqsize > 0 {
8
        lock(&sched.lock)
9
        gp = globrunqget(_g_.m.p.ptr(), 1)
10
        unlock(&sched.lock)
11
    }
12

13
    // 从 P 的本地队列获取
14
    if gp == nil {
15
        gp, inheritTime = runqget(_g_.m.p.ptr())
16
    }
17

18
    // 本地队列空了，阻塞查找
19
    if gp == nil {
20
        gp, inheritTime = findrunnable()
21
    }
22

23
    execute(gp, inheritTime)
24
}

1
func execute(gp *g, inheritTime bool) {
2
    _g_ := getg()
3
    _g_.m.curg = gp     // M 绑定新 G
4
    gp.m = _g_.m
5
    casgstatus(gp, _Grunnable, _Grunning)  // 状态迁移
6
    gp.preempt = false
7
    gp.stackguard0 = gp.stack.lo + _StackGuard
8
    if !inheritTime {
9
        _g_.m.p.ptr().schedtick++
10
    }
11
    gogo(&gp.sched)     // 切换到 G 的栈执行
12
}

1
func goexit0(gp *g) {
2
    _g_ := getg()
3
    casgstatus(gp, _Grunning, _Gdead)  // G 变为死亡状态
4
    gp.m = nil
5
    ...
6
    dropg()                // 解除 M 和 G 的绑定
7
    gfput(_g_.m.p.ptr(), gp)  // G 放入 P 的空闲链表，复用
8
    schedule()             // 重新进入调度循环
9
}

1
func runqsteal(_p_, p2 *p, stealRunNextSg bool) *g {
2
    t := _p_.runqtail
3
    n := runqget2(p2, &_p_.runq, t, runqsize, stealRunNextSg)
4
    if n == 0 {
5
        return nil
6
    }
7
    n--  // 留一个返回给调用者
8
    _p_.runqtail = t + n
9
    return _p_.runq[(t+n)%uint32(len(_p_.runq))].ptr()
10
}

1
func runqput(_p_ *p, gp *g, next bool) {
2
    if next {
3
        // 优先放入 runnext
4
        retryNext:
5
        oldnext := _p_.runnext
6
        if !_p_.runnext.cas(oldnext, guintptr(unsafe.Pointer(gp))) {
7
            goto retryNext
8
        }
9
        if oldnext == 0 {
10
            return
11
        }
12
        // 把被挤掉的旧 runnext 放入 runq
13
        gp = oldnext.ptr()
14
    }
15
    // 放入本地队列的尾部
16
    retry:
17
    h := atomic.LoadAcq(&_p_.runqhead)
18
    t := _p_.runqtail
19
    if t-h < uint32(len(_p_.runq)) {
20
        _p_.runq[t%uint32(len(_p_.runq))].set(gp)
21
        atomic.StoreRel(&_p_.runqtail, t+1)
22
        return
23
    }
24
    // 本地队列满了，转移到全局队列
25
    runqputslow(_p_, gp, h, t)
26
}

1
func reentersyscall(pc, sp uintptr) {
2
    _g_ := getg()
3
    _g_.stackguard0 = stackPreempt  // 禁止栈增长
4
    save(pc, sp)                     // 保存当前 PC/SP
5
    casgstatus(_g_, _Grunning, _Gsyscall)  // 状态迁移
6
    pp := _g_.m.p.ptr()
7
    pp.m = 0          // P 与 M 解绑
8
    _g_.m.oldp.set(pp) // 记住原来的 P
9
    _g_.m.p = 0
10
    atomic.Store(&pp.status, _Psyscall)  // P 进入 _Psyscall 状态
11
}

1
func exitsyscall() {
2
    _g_ := getg()
3
    oldp := _g_.m.oldp.ptr()
4
    _g_.m.oldp = 0
5

6
    // 快速路径：尝试重新绑定原来的 P
7
    if exitsyscallfast(oldp) {
8
        casgstatus(_g_, _Gsyscall, _Grunning)
9
        return
10
    }
11

12
    // 慢速路径：切换到 g0 栈，重新调度
13
    mcall(exitsyscall0)
14
}

1
func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerpc uintptr) *g {
2
    _g_ := getg()
3
    _p_ := _g_.m.p.ptr()
4

5
    // 从 P 的 gFree 链表获取空闲 G
6
    newg := gfget(_p_)
7
    if newg == nil {
8
        // 没有空闲 G，创建新的，分配 2KB 栈
9
        newg = malg(_StackMin)
10
        casgstatus(newg, _Gidle, _Gdead)
11
        allgadd(newg)
12
    }
13

14
    // 计算新 G 的栈顶位置，拷贝参数到新栈
15
    totalSize := 4*sys.RegSize + uintptr(narg) + sys.MinFrameSize
16
    sp := newg.stack.hi - totalSize
17
    if narg > 0 {
18
        memmove(unsafe.Pointer(sp), argp, uintptr(narg))
19
    }
20

21
    // 设置调度信息
22
    newg.sched.sp = sp
23
    newg.sched.pc = funcPC(goexit) + sys.PCQuantum  // 关键：pc 设为 goexit
24
    newg.sched.g = guintptr(unsafe.Pointer(newg))
25
    gostartcallfn(&newg.sched, fn)  // 把 fn 的地址压栈，覆盖 pc
26

27
    casgstatus(newg, _Gdead, _Grunnable)
28
    newg.goid = int64(_p_.goidcache)
29
    _p_.goidcache++
30
    return newg
31
}

1
func newstack() {
2
    _g_ := getg()
3

4
    // 检查是否是抢占请求
5
    if _g_.stackguard0 == stackPreempt {
6
        // 先检查是否可以安全抢占
7
        if canPreemptM(_g_.m) {
8
            gopreempt_m(_g_)  // 让出 CPU
9
            return
10
        }
11
        // 不能抢占，恢复 stackguard0 继续执行
12
        _g_.stackguard0 = _g_.stack.lo + _StackGuard
13
    }
14

15
    // 分配新栈（2 倍大小）
16
    oldsize := _g_.stack.hi - _g_.stack.lo
17
    newsize := oldsize * 2
18
    newstack := stackalloc(uint32(newsize))
19

20
    // 拷贝旧栈内容到新栈
21
    memmove(unsafe.Pointer(newstack.hi-UsedSize), ..., UsedSize)
22

23
    // 调整栈上的指针（指向旧栈的地址需要更新为新栈地址）
24
    gentraceback(..., adjustpointer, ...)
25

26
    // 切换到新栈
27
    _g_.stack = newstack
28
    _g_.stackguard0 = newstack.lo + _StackGuard
29
    gogo(&_g_.sched)  // 跳回 G 继续执行
30
}