1
type g struct {
2
    // 栈参数
3
    stack       stack   // 栈范围 [stack.lo, stack.hi)
4
    stackguard0 uintptr // 栈溢出检查，用于 go 的栈增长
5
    stackguard1 uintptr // 栈溢出检查，用于 cgo 的栈增长
6

7
    // 与调度器交互的字段
8
    m            *m      // 当前绑定到的 M
9
    sched        gobuf   // 保存调度上下文（PC、SP 等）
10
    atomicstatus atomic.Uint32 // goroutine 状态
11
    goid         uint64  // goroutine ID
12

13
    // 其他字段省略...
14
}
15

16
type gobuf struct {
17
    sp   uintptr // 栈指针
18
    pc   uintptr // 程序计数器
19
    g    guintptr // 指向 goroutine 的指针
20
    ret  uintptr  // 返回值
21
    // ...
22
}
23

24
type stack struct {
25
    lo uintptr // 栈底地址
26
    hi uintptr // 栈顶地址
27
}

1
type m struct {
2
    g0      *g     // 用于执行调度代码的特殊 goroutine
3
    curg    *g     // 当前正在运行的 goroutine
4
    p       puintptr // 绑定的 P
5
    nextp   puintptr // 即将绑定的 P（用于 handoff）
6
    oldp    puintptr // 系统调用前的 P
7

8
    // 用于信号处理和系统调用
9
    tls     [tlsSlots]uintptr // 线程本地存储
10
    mstartfn func()          // M 启动时执行的函数
11

12
    // 用于阻塞/唤醒
13
    park    note
14
    alllink *m // 链接到 allm 列表
15

16
    // 其他字段省略...
17
}

1
type p struct {
2
    id          int32
3
    status      uint32 // P 的状态
4
    link        puintptr // 链接到空闲 P 列表
5

6
    m           muintptr // 绑定的 M
7

8
    // 本地运行队列
9
    runqhead    uint32
10
    runqtail    uint32
11
    runq        [256]guintptr // 本地 G 队列
12
    runnext     guintptr      // 优先运行的 G
13

14
    // 内存分配缓存
15
    mcache      *mcache // 内存分配器的本地缓存
16

17
    // GC 相关
18
    gcAssistTime     int64
19
    gcBgMarkWorker   guintptr
20

21
    // 其他字段省略...
22
}

1
func schedule() {
2
    mp := getg().m
3

4
    // 尝试从各种来源获取可运行的 G
5
    var gp *g
6
    if gp == nil {
7
        // 1. 优先检查全局队列（每 61 次调度检查一次全局队列）
8
        if mp.p.ptr().schedtick%61 == 0 && sched.runqsize > 0 {
9
            lock(&sched.lock)
10
            gp = globrunqget(mp.p.ptr(), 1)
11
            unlock(&sched.lock)
12
        }
13
    }
14
    if gp == nil {
15
        // 2. 从本地队列获取
16
        gp, inheritTime = runqget(mp.p.ptr())
17
    }
18
    if gp == nil {
19
        // 3. 从全局队列、网络轮询器或其他 P 窃取
20
        gp, inheritTime = findrunnable()
21
    }
22

23
    // 执行找到的 goroutine
24
    execute(gp, inheritTime)
25
}

1
func findrunnable() (gp *g, inheritTime bool) {
2
    mp := getg().m
3

4
top:
5
    pp := mp.p.ptr()
6

7
    // 检查全局队列
8
    if sched.runqsize > 0 {
9
        lock(&sched.lock)
10
        gp := globrunqget(pp, 0)
11
        unlock(&sched.lock)
12
        if gp != nil {
13
            return gp, false
14
        }
15
    }
16

17
    // 检查网络轮询器
18
    if netpollinited() && netpollWaiters.Load() > 0 {
19
        if list := netpoll(0); !list.empty() {
20
            gp := list.pop()
21
            injectglist(&list)
22
            return gp, false
23
        }
24
    }
25

26
    // 从其他 P 窃取
27
    if !mp.spinning {
28
        mp.spinning = true
29
    }
30
    for i := 0; i < 4; i++ {
31
        for enum := stealOrder.start(fastrand()); !enum.done(); enum.next() {
32
            if sched.gcwaiting.Load() {
33
                goto top
34
            }
35
            p2 := allp[enum.position()]
36
            if pp == p2 {
37
                continue
38
            }
39
            // 尝试从 p2 窃取一半的 G
40
            if gp := runqsteal(pp, p2, stealRunNextQ); gp != nil {
41
                return gp, false
42
            }
43
        }
44
    }
45

46
    // 没有找到可运行的 G，进入休眠
47
    stopm()
48
    goto top
49
}

1
func handoffp(pp *p) {
2
    // 如果 P 本地有任务或全局有任务
3
    if pp.runqhead != pp.runqtail || sched.runqsize > 0 {
4
        startm(pp, false)
5
        return
6
    }
7

8
    // 如果有 GC 工作
9
    if gcBlackenEnabled != 0 && gcMarkWorkAvailable(pp) {
10
        startm(pp, false)
11
        return
12
    }
13

14
    // 没有工作，将 P 放入空闲列表
15
    pidleput(pp)
16
}