1
// src/runtime/runtime2.go (简化版)
2
type g struct {
3
    stack       stack      // 栈的边界 [lo, hi]
4
    sched       gobuf      // 调度上下文（保存的寄存器）
5
    goid        int64      // goroutine ID
6
    m           *m         // 当前绑定的 M
7
    ...
8
}
9

10
type gobuf struct {
11
    sp   uintptr  // 保存的栈指针
12
    pc   uintptr  // 保存的程序计数器
13
    g    guintptr // 指向 g 的指针
14
    ret  uintptr  // 返回值
15
    bp   uintptr  // 保存的基址指针（帧指针）
16
}

1
goroutine A 的栈（高地址 → 低地址）：
2
┌──────────────────────┐ ← stack.hi
3
│  frame 3             │
4
│  frame 2             │
5
│  frame 1             │ ← SP_A
6
└──────────────────────┘ ← stack.lo
7

8
goroutine B 的栈：
9
┌──────────────────────┐ ← stack.hi
10
│  frame 2             │
11
│  frame 1             │ ← SP_B
12
└──────────────────────┘ ← stack.lo

1
切换前（运行 goroutine A）：
2
  RSP = SP_A（指向 A 的栈顶）
3
  RIP = A 的当前指令
4

5
gogo(gobuf_B)：
6
  RSP = SP_B（切换到 B 的栈顶）
7
  RIP = PC_B（跳转到 B 的执行位置）
8

9
切换后（运行 goroutine B）：
10
  RSP = SP_B
11
  RIP = B 的当前指令

1
func BenchmarkGoroutineSwitch(b *testing.B) {
2
    var wg sync.WaitGroup
3
    ch := make(chan struct{})
4

5
    // 启动一个 goroutine 做乒乓切换
6
    go func() {
7
        for i := 0; i < b.N; i++ {
8
            <-ch  // 阻塞
9
            ch <- struct{}{}  // 唤醒对方
10
        }
11
    }()
12

13
    b.ResetTimer()
14
    for i := 0; i < b.N; i++ {
15
        ch <- struct{}{}  // 唤醒对方
16
        <-ch  // 阻塞
17
    }
18
}