Go GMP 调度通识:G、P、M 与阻塞syscall

Go GMP 调度通识:G、P、M 与阻塞syscall

Hello,我是小兔大白糖。 读完能用 G/P/M 解释协程调度直觉,并理解阻塞 syscall 与网络轮询对线程的影响。

GMP用 G(协程)、P(逻辑处理器)、M(线程)解释调度;阻塞 syscall 与 netpoll 决定会不会「占住线程」。

估计阅读时间:16 分钟

G、P、M 三者关系
G、P、M 三者关系 · 点击查看 SVG 原图

1. 这是什么?概念怎么定义

一句话描述

Go 的 GMP(Goroutine-Machine-Processor)调度器是 Go 运行时的心脏,它将数百万的 goroutine 高效调度在少量 OS 线程上执行,配合其独特的栈内存管理,实现了比 Java 线程池高出 100 倍以上的并发能力。

与 Java 对比

维度Go GMPJava JVM
调度单位goroutine (~2KB)Thread (1MB 固定)
调度器协作+抢占混合抢占式(OS 级别)
调度策略work-stealing线程池 + ForkJoinPool
栈管理动态扩展(2KB→1GB)固定大小(1MB)
GC 影响并发标记,几乎无 STWG1/ZGC 优化但仍有停顿
最大并发数数十万-百万通常数千

2. GMP 模型深度解析

2.1 三元组结构

┌─────────────────────────────────────────────────────────────────┐
│                         P (Processor)                          │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │              本地 Goroutine 队列 (最多 256个)            │    │
│  │   G1  G2  G3  G4  G5  ...  Gn                           │    │
│  └─────────────────────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────────────────┘
                              ↕
┌─────────────────────────────────────────────────────────────────┐
│                    全局 Goroutine 队列                           │
│   G_global1  G_global2  G_global3  ...                          │
└─────────────────────────────────────────────────────────────────┘

┌─────────┐     ┌─────────┐     ┌─────────┐
│   M1    │     │   M2    │     │   M3    │
│ (Machine)│    │ (Machine)│    │ (Machine)│
└────┬────┘     └────┬────┘     └────┬────┘
     │                │                │
     ▼                ▼                ▼
┌─────────┐     ┌─────────┐     ┌─────────┐
│ OS Thread│     │ OS Thread│     │ OS Thread│
│  (Linux) │     │  (Linux) │     │  (Linux) │
└─────────┘     └─────────┘     └─────────┘

2.2 G(Goroutine)结构体

// src/runtime/runtime2.go
type g struct {
    // 栈相关
    stack       stack   // 栈区间 [stack.lo, stack.hi)
    stackguard0 uintptr // 栈溢出检测点
    stackguard1 uintptr
 
    // 调度状态
    sched        gobuf   // 调度上下文(PC、SP 等)
    goid         int64   // goroutine ID
    schedlink    guintptr // 链接到下一个 g
    status       uint32  // _Gwaiting, _Grunnable, _Grunning, ...
 
    // 阻塞/等待
    waitreason   waitReason
    param        unsafe.Pointer
   waitsince    int64
 
    // 抢占请求
    preempt      bool    // 抢占请求标志
    preemptStop  bool    // 抢占后停止
    preemptShrink bool   // 抢占时收缩栈
}

关键点:

  • 初始栈大小仅 2KB,远小于 Java 的 1MB
  • sched 保存程序计数器 PC、栈指针 SP、寄存器等,支撑上下文切换
  • status 反映 goroutine 所处状态机位置

2.3 P(Processor)结构体

type p struct {
    id          int32
    status      uint32 // _Pidle, _Prunning, _Psyscall, _Pgcstop
 
    // 本地 runnable 队列
    runqhead    uint32
    runqtail    uint32
    runq        [256]guintptr
 
    // runnext:下一个可运行的 goroutine(优先执行)
    runnext     guintptr
 
    // 关联的 M
    m           muintptr
 
    // P 本地的 cache
    mcache      *mcache
    pcache      pageCache
    deferpool   [5]*_defer // 不同大小的 defer 池
 
    // GC 相关
    gcBgMarkWorker       guintptr
    gcMarkWorkerMode     gcMarkWorkerMode
}

本地队列容量:最多 256 个 goroutine,超出则放入全局队列。

2.4 M(Machine/OSThread)结构体

type m struct {
    g0          *g     // 特殊的 goroutine,用于调度和运行时
    CURCPU      int32  // 绑定的 CPU ID
    tls         [6]uintptr // Thread Local Storage
 
    // 绑定到的高速缓存
    p           *p     // 当前关联的 P
    nextp       *p     // 下一个要绑定的 P
    oldp        *p     // 被抢占前的 P
 
    // 等待中的 spinning M
    spinning    bool
    blocked     bool
    inwb        bool
}

3. Work-Stealing 调度算法

3.1 调度流程图

                    ┌──────────────────────────────────────────────┐
                    │              M 执行 goroutine                 │
                    │  ┌────────────────────────────────────────┐  │
                    │  │  G 正在运行                             │  │
                    │  └────────────────────────────────────────┘  │
                    └──────────────────────┬───────────────────────┘
                                           │ G 阻塞/让出
                    ┌──────────────────────▼───────────────────────┐
                    │           检查 P 本地队列                     │
                    │  ┌────────────────────────────────────────┐  │
                    │  │ 本地队列有 G? → 取出执行                  │  │
                    │  └────────────────────────────────────────┘  │
                    │                  │ 无                        │
                    │                  ▼                           │
                    │  ┌────────────────────────────────────────┐  │
                    │  │ 从全局队列获取 G(每 61 次操作一次)       │  │
                    │  └────────────────────────────────────────┘  │
                    │                  │ 无                        │
                    │                  ▼                           │
                    │  ┌────────────────────────────────────────┐  │
                    │  │ work-stealing:从其他 P 偷取一半队列      │  │
                    │  └────────────────────────────────────────┘  │
                    └──────────────────────────────────────────────┘

3.2 steal 偷取实现

// src/runtime/proc.go
func runqsteal(p *p, p2 *p, t *m) *g {
    // 最多偷取 p2 本地队列的 1/2
    for i := 0; i < 2; i++ {
        for j := 0; j < int(p2.runqtail-p2.runqhead)/2; j++ {
            g := p2.runq[(p2.runqhead+j)%uint32(len(p2.runq))]
            if atomiccmp(&p2.runqhead, p2.runqhead+1, p2.runqhead) {
                // 成功偷取,放到本地队列尾部
                p.runq[p.runqtail%uint32(len(p.runq))] = g
                atomicstore(&p.runqtail, p.runqtail+1)
            }
        }
    }
    return nil
}

3.3 与 Java 对比

特性Go Work-StealingJava ForkJoinPool
队列结构本地队列 + 全局队列work-stealing 双端队列
偷取策略从其他 P 偷取一半从其他线程队列头部偷取
优先级本地队列 > 全局 > 偷取自身队列 > 偷取
线程协作无需显式配合需要 join() 等协作

4. 栈内存管理

4.1 栈帧结构

┌─────────────────────┐  ← stack.hi (高地址)
│    调用者栈帧         │
├─────────────────────┤
│   当前函数局部变量    │
├─────────────────────┤
│   返回地址           │
├─────────────────────┤  ← SP (Stack Pointer)
│   当前栈帧          │
│   (growing ↓)       │
└─────────────────────┘  ← stack.lo (低地址)

初始栈: 2KB (g0: 8KB)
最大栈: 1GB (64位系统)

4.2 栈分裂(Stack Split)

// 编译器在函数入口插入这段代码
func foo() {
    // 检查: stackguard0 >= SP + StackSmall?
    // 如果栈空间不足,触发 split 和 grow
 
    // ... 函数体 ...
 
    // 恢复收缩(如果之前有 shrink)
}

StackSmall 阈值:_StackSmall = 128 字节

当函数栈帧超过 128 字节时,编译器插入栈检查代码:

// 检查伪代码
if SP > g.stackguard0 - _StackLimit {
    // 需要扩展栈
    morestackc()
}

4.3 动态扩展机制

┌──────────────────────────────────────────────────────┐
│                    扩展前: 2KB                       │
│  ┌─────────────────────────────────────────────┐     │
│  │  G1 running...                              │     │
│  │  遇到深层递归,需要更多栈空间                  │     │
│  └─────────────────────────────────────────────┘     │
└──────────────────────────────────────────────────────┘

         ↓ morestack() 被调用

┌──────────────────────────────────────────────────────┐
│                    扩展后: 4KB (翻倍)                  │
│  ┌─────────────────────────────────────────────┐     │
│  │  G1 running...                              │     │
│  │  新分配的栈空间                                │     │
│  └─────────────────────────────────────────────┘     │
│  ┌─────────────────────────────────────────────┐     │
│  │  旧栈内容(复制到新位置)                       │     │
│  └─────────────────────────────────────────────┘     │
└──────────────────────────────────────────────────────┘

4.4 与 Java 对比

维度Go 动态栈Java 固定栈
初始大小2KB(g0: 8KB)1MB
最大大小1GB(64位)由 -Xss 决定
扩展方式翻倍 + 栈复制不支持动态扩展
内存浪费极少大量(大量线程时)
栈帧成本~2KB 初始~1MB 固定

Go 栈扩展示例:

func recursiveDeep(n int) int {
    if n == 0 {
        return 0
    }
    // 每次递归只需要很小的栈空间
    // 初始 2KB 可支持数千次递归
    return recursiveDeep(n-1) + n
}

5. 抢占式调度

5.1 sysmon 监控线程

Go 运行时启动一个 sysmon(system monitor)goroutine:

// src/runtime/proc.go
func sysmon() {
    for {
        // 每 10μs 或 20μs 检查一次
        usleep(10)
 
        // 检查需要被抢占的 P
        for p := allp[0]; p != nil; p = p.link {
            if p.preempt {
                // 发送抢占请求
                preemptPark(p)
            }
        }
 
        // 检查长时间运行的 G
        checkdead()
    }
}

5.2 抢占触发条件

// 触发抢占的场景
const (
    // 1. GC 开始时
    _PGcstop = 4  // 停止所有 P 以便 GC
 
    // 2. 系统调用阻塞过久
    // 3. Goroutine 运行超过 10ms
    forcePreemptMS = 10
)

5.3 抢占信号机制

// 当 M 执行 G 时收到抢占信号
// OS 会在指令之间插入检查点
 
// Linux: 通过 SIGURG 信号实现抢占
// 编译器插入:
//   - 函数入口的栈检查
//   - 循环之间的 preemptCheck

5.4 与 Java 对比

维度Go 抢占式调度Java 抢占式调度
抢占触发sysmon + GC协作OS 定时器中断
响应延迟~10μs取决于 OS 配置
GC 协调STW 时间极短G1: 200ms+
公平性相对公平OS 保证绝对公平

6. Go GC 机制演进

6.1 GC 发展历史

v1.0 (2012)    → 标记清除 (Stop the World)
v1.2 (2013)    → 并发标记(仍有 STW)
v1.5 (2015)    → 三色标记 + 并发清理
v1.8 (2017)    → 混合写屏障(消除 STW)
v1.10+         → 持续优化

6.2 三色标记原理

初始:所有对象为白色
     ○ ○ ○ ○ ○ ○ ○ ○
        ↓ Mark 阶段
标记可达对象为灰色
     ○ ○ ● ○ ○ ○ ○ ○
        ↓ 继续标记
可达对象变黑色
     ○ ○ ● ● ● ○ ○ ○
        ↓ 清理阶段
白色对象被回收
     ○ ○ ● ● ● ○ ○ ○
     ↓↓↓      ↓↓↓
   回收      保留

6.3 混合写屏障(Hybrid Write Barrier)

// Go 1.8 引入的 Dijkstra-style 写屏障
func writeBarrier(slot *unsafe.Pointer, ptr unsafe.Pointer) {
    // 1. 将被覆盖的对象标记为灰色(如果尚未标记)
    shade(*slot)
 
    // 2. 写入新指针
    *slot = ptr
 
    // 3. 将新指针指向的对象标记为灰色
    shade(ptr)
}

消除 STW 的关键:写屏障保证在并发标记期间,引用变更不会丢失已标记的对象。

6.4 GC 调优参数

# GOGC: 默认 100(当堆内存增长 100% 时触发 GC)
# 表示:当前存活对象占用 X 内存,当堆达到 2X 时触发 GC
GOGC=50   # 更激进,内存占用少但 CPU 开销大
GOGC=200  # 更保守,内存占用多但 GC 频率低
 
# GOMEMLIMIT: 内存上限(1.19+)
GOMEMLIMIT=10GiB
 
# GOMAXPROCS: 影响并发 GC 线程数
GOMAXPROCS=8

6.5 与 Java G1/ZGC 对比

维度Go GCJava G1 GCJava ZGC
算法三色标记+混合写屏障区域化+并发标记着色指针+读屏障
STW<1ms(通常 0.1-0.5ms)100-500ms<1ms
GC 线程工作窃取Parallel并发
内存占用2x 堆增长1.5x 堆增长<1.1x
延迟P99 < 1msP99 数十 msP99 < 1ms
吞吐低于 G1高吞吐中等

7. 项目代码示例

7.1 本项目中的 goroutine 使用示例

文件: internal/service/message/message_service.go

// 消息处理:每个连接一个 goroutine
func (s *MessageService) HandleWebSocket(conn *websocket.Conn, userID string) {
    // 每个连接独立 goroutine,无阻塞
    for {
        msg, err := conn.ReadMessage()
        if err != nil {
            // 连接关闭,goroutine 自然结束
            return
        }
        // 处理消息(无锁设计,利用 channel)
        s.msgChan <- msg
    }
}
 
// channel fan-out 模式
func (s *MessageService) StartWorkers(ctx context.Context) {
    for i := 0; i < s.workerCount; i++ {
        go s.worker(ctx, i)
    }
}
 
func (s *MessageService) worker(ctx context.Context, id int) {
    for {
        select {
        case msg := <-s.msgChan:
            s.processMessage(msg)
        case <-ctx.Done():
            return
        }
    }
}

7.2 本项目中的内存优化示例

文件: pkg/utils/sync/pool.go

// 使用 sync.Pool 减少 GC 压力
var bytesBufferPool = sync.Pool{
    New: func() interface{} {
        b := make([]byte, 4096)
        return &bytesBuffer{data: b}
    },
}
 
func GetBuffer() *bytesBuffer {
    return bytesBufferPool.Get().(*bytesBuffer)
}
 
func PutBuffer(b *bytesBuffer) {
    b.Reset()
    bytesBufferPool.Put(b)
}

8. 业界应用案例

8.1 字节跳动微服务架构

场景:抖音后端消息系统

  • 问题:百万级 WebSocket 长连接
  • Go 方案:
    • goroutine per connection
    • channel 作为消息总线
    • sync.Pool 复用缓冲区
  • 效果:单机 50 万连接,内存 < 2GB

8.2 Google gvisor

场景:沙箱容器运行时

  • Go 的作用:用 Go 编写用户态内核
  • 核心依赖:
    • GMP 调度模拟器
    • 协程替代线程
  • 效果:比 native 容器 overhead < 5%

8.3 Cloudflare edge network

场景:边缘网络处理

  • Go 的作用:QUIC 协议实现
  • 核心优势:
    • 栈内存管理(2KB vs 1MB)
    • 快速启动大量协程
  • 效果:单个服务器处理千万级请求

9. 业务场景对照

9.1 什么场景用 Go 的 GMP 模型

场景适用度原因
WebSocket 长连接⭐⭐⭐⭐⭐goroutine 轻量,百万连接可行
RPC 高并发调用⭐⭐⭐⭐⭐并发量大,阻塞少
流式数据处理⭐⭐⭐⭐channel + pipeline 天然适合
定时任务调度⭐⭐⭐⭐time.Sleep 不占 CPU
批处理作业⭐⭐⭐goroutine 过多需管理

9.2 注意事项

// ❌ 错误:goroutine 泄漏
func badExample() {
    for {
        go func() {
            // 没有退出条件,永远无法结束
            time.Sleep(time.Hour)
        }()
    }
}
 
// ✓ 正确:使用 context 控制生命周期
func goodExample(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            return
        case msg := <-ch:
            // 处理消息
        }
    }
}

10. 常见问题与解答

Q1: goroutine 和 Java 线程的根本区别?

答:goroutine 是 Go 运行时管理的用户态协程,由 GMP 调度在 OS 线程上;Java 线程是 OS 管理的内核态线程。goroutine 切换代价约为 ~200ns,Java 线程切换约 ~10μs。

Q2: 为什么 Go 不需要虚拟线程(Loom)?

答:Go 的 goroutine 本身就是轻量级协程,初始 2KB vs Java 1MB,Go 1.18+ 的协程已有类似 Loom 的用户态调度能力。

Q3: GMP 中 P 的数量默认是多少?

答:默认等于 CPU 核心数(GOMAXPROCS),可通过环境变量或 runtime.GOMAXPROCS() 调整。

Q4: goroutine 泄漏如何排查?

答:使用 go trace 或 pprof:

go tool trace trace.out
# 查看 goroutine 数量变化

Q5: 全局队列和本地队列如何平衡?

答:每执行 61 次本地队列操作,才检查一次全局队列,这是为了减少全局锁竞争。

Q6: Go 的 GC 对延迟敏感型服务影响?

答:Go 1.8+ 的混合写屏障几乎消除了 STW,P99 延迟通常 < 1ms,远优于 Java G1。

Q7: sysmon 会占用 CPU 吗?

答:sysmon 是特殊的 goroutine,不占用 P 资源(运行在 M 上),只在必要时检查和发送抢占信号。


参考资料

  1. Go Runtime 源码: src/runtime/proc.go, src/runtime/stack.go
  2. 《Go 专家编程》- 华为云团队
  3. Go GC 官方博客: https://go.dev/blog/gc-pacer
  4. 字节跳动技术博客: https://bytedance.tech/blog