Golang GMP 协程调度器模型原理解析

林舟

发布时间：2026-10-15 | 3人浏览过

原创

本文详细解析Golang协程调度器的核心原理，聚焦于GMP模型中G、M、P的结构定义与协作关系，并解释Work Stealing等调度机制如何实现高效的并发处理，帮助开发者深入理解Go语言的底层执行逻辑。

Goroutine与操作系统的映射

在Go语言中，程序运行的基本单元是Goroutine。与Java等语言中一对一映射操作系统线程不同，Goroutine更为轻量级，且不与操作系统线程建立固定对应关系。然而，执行程序最终仍需依赖操作系统的原生线程。调度器（Scheduler）的核心作用，就是将逻辑上的Goroutine调度到物理的操作系统线程上运行。

GMP 模型结构解析

Go采用GMP（Goroutine-Processor-Machine）模型进行调度。其中：

G (Goroutine)：代表一个逻辑执行单元，存储协程的执行栈、状态、指令指针等上下文信息。
P (Processor)：处理器，可视为本地调度队列及运行时环境的抽象。P的数量默认等于CPU核心数。只有持有P的G才能被执行。
M (Machine)：代表操作系统的一个原生线程，负责绑定P并在内核态执行具体的机器指令。

数据结构实现细节

G 的数据结构如下所示：

type g struct {
    stack       stack   // goroutine自己的栈
    m            *m      // 当前正在执行的machine
    sched        gobuf   // 保存现场，用于goroutine切换恢复
    atomicstatus uint32  // 状态如Grunnable、GRunning等
    goid         int64   // Goroutine唯一标识符
    schedlink    guintptr // 链表下一个g
    preempt       bool   // 抢占标记
    lockedm        muintptr // 锁定的M，指定由该M继续执行
    gopc           uintptr  // 创建该goroutine的代码行地址
    startpc        uintptr  // 执行函数的起始地址
}

P 的数据结构如下所示：

type p struct {
    id          int32   // P的ID
    status      uint32  // 状态
    link        puintptr // 链表下一个P
    m           muintptr // 当前绑定的M
    mcache      *mcache  // 缓存内存分配信息

    runqhead uint32
    runqtail uint32
    runq     [256]guintptr // 本地可运行的G队列
    
    runnext guintptr // 优先级较高的runnable G
    gFree struct {
        gList
        n int32
    }

    gcBgMarkWorker       guintptr // GC后台标记工作者
    gcw gcWork                     // GC工作队列
}

M 的数据结构如下所示：

type m struct {
    g0      *g     // 每个M独有的g0（管理用栈）
    curg          *g       // 当前正在运行的普通g
    p             puintptr // 当前使用的P
    nextp         puintptr // M唤醒时优先获取的P
    id            int64   // Machine ID
    spinning      bool    // 是否处于自旋等待状态
    park          note
    allink       *m      // 全局M链表链接
    schedlink     muintptr // 调度链表下一个M
    mcache        *mcache // 专属内存缓存
    lockedg       guintptr // 被特殊锁定的g
    freelink      *m      // 空闲M链表链接
}

通过这种GMP模型设计，G可以在不同的P或M之间迁移。对于操作系统而言，只能看到数量有限的M在执行连续的任务，从而大大减少了线程级的上下文切换开销，显著提升了并发性能。