当前位置：首页 > news >正文

【Go并发编程】Goroutine 调度器揭秘：从 GMP 模型到 Work Stealing 算法

news 来源：原创 2025/5/9 19:03:57

每天一篇Go语言干货，从核心到百万并发实战，快来关注魔法小匠，一起探索Go语言的无限可能！

在 Go 语言中，Goroutine 是一种轻量级的并发执行单元，它使得并发编程变得简单高效。而 Goroutine 的高效调度机制是 Go 语言在并发处理上的一大亮点。本文将深入剖析 Go 语言的 Goroutine 调度器，从 GMP 模型到 Work Stealing 算法，带你一探究竟。

一、Goroutine 调度器的背景

Go 语言的并发模型基于 Goroutine，它是一种轻量级的线程，由 Go 运行时（runtime）自动管理。Goroutine 的调度机制决定了多个 Goroutine 如何高效地映射到操作系统线程上执行。与传统线程（Thread）相比具有以下优势：

内存占用仅2KB（线程默认1MB）
上下文切换成本仅0.2μs（线程约1μs）
创建速度达到微秒级（线程需毫秒级）

但是Goroutine本质上是用户态线程，需要依赖GMP调度器将其映射到操作系统线程（M）执行。

二、GMP 模型：Goroutine 调度的核心

Goroutine 的调度基于 GMP 模型，即 Goroutine（G）、Machine（M）和 P（Processor）的组合。这个模型实现了从 N:1（用户态线程到内核态线程）到 N:M（用户态线程到内核态线程的灵活映射）的调度。

1. Goroutine（G）

Goroutine 是用户定义的协程，它代表了并发执行的任务。创建 Goroutine 的底层方法是newproc 函数，它会将 Goroutine 放入 P 的本地队列中。如果本地队列已满，则放入全局队列中。

go func() {
    // 任务代码
}()

2. Machine（M）

Machine 代表操作系统线程，是 Go 运行时与操作系统交互的接口。Go 运行时会根据需要创建和销毁 M，以适应不同的并发场景。

3. Processor（P）

Processor 是 Go 运行时中的调度上下文，它负责管理 Goroutine 的调度。每个 P 有自己的本地队列，用于存储待执行的 Goroutine。

4.GMP模型示意图

通过该示意图可以了解到完整的GMP模型关系。

全局队列：本地队列（Processor调度器管理）满了的情况下，将会把新创建的Goroutine加入到全局队列中排队等待执行。

本地队列：存放即将执行的Goroutine，每个processor中的goroutine将并行执行。

Goroutine（G）：图中的每个圆形图标G就是代表一个Groutine。

Processor（P）：管理当前调度器内的本地队列，并负责管理 Goroutine 的调度，用于存储待执行的 Goroutine。processor和groutine是N:M的关系。

内核线程（M）：每个M代表了一个内核线程，操作系统调度器负责把内核线程分配到CPU的核上执行。

三、调度器的工作流程

Go 调度器的核心任务是从队列中获取可执行的 Goroutine，并将其分配给可用的 M 执行。

1. 本地队列

每个 P 都有一个本地队列，调度器会优先从本地队列中获取 Goroutine 执行。如果本地队列为空，则会尝试从全局队列获取。

2. 全局队列

全局队列是所有 P 共享的队列，用于存储未被分配的 Goroutine。当本地队列为空时，调度器会尝试从全局队列中获取 Goroutine。

3. Work Stealing（工作窃取）

如果本地队列和全局队列都为空，调度器会采用 Work Stealing 算法，从其他 P 的本地队列中“偷取” Goroutine。这种策略可以实现线程之间的负载均衡。

func runqsteal(pp, p2 *p, stealRunNextG bool) *g {
    t := pp.runqtail
    n := runqgrab(p2, &pp.runq, t, stealRunNextG)
    if n == 0 {
        return nil
    }
    n--
    gp := pp.runq[(t+n)%uint32(len(pp.runq))].ptr()
    if n == 0 {
        return gp
    }
    h := atomic.LoadAcq(&pp.runqhead)
    if t-h+n >= uint32(len(pp.runq)) {
        throw("runqsteal: runq overflow")
    }
    atomic.StoreRel(&pp.runqtail, t+n)
    return gp
}

四、抢占式调度

Go 调度器采用抢占式调度策略，以防止某个 Goroutine 占用过多 CPU 资源。在 Go 1.14 之后，调度器在任何安全点都可以进行抢占。

func findRunnable() (gp *g, inheritTime, tryWakeP bool) {
    mp := getg().mtop
    pp := mp.p.ptr()
    // 每61次调度周期就检查一次全局G队列
    if pp.schedtick%61 == 0 && sched.runqsize > 0 {
        lock(&sched.lock)
        gp := globrunqget(pp, 1)
        unlock(&sched.lock)
        if gp != nil {
            return gp, false, false
        }
    }
    // 本地队列
    if gp, inheritTime := runqget(pp); gp != nil {
        return gp, inheritTime, false
    }
    // 全局队列
    if sched.runqsize != 0 {
        lock(&sched.lock)
        gp := globrunqget(pp, 0)
        unlock(&sched.lock)
        if gp != nil {
            return gp, false, false
        }
    }
    // 工作窃取
    if mp.spinning || 2*sched.nmspinning.Load() < gomaxprocs-sched.npidle.Load() {
        if !mp.spinning {
            mp.becomeSpinning()
        }
        gp, inheritTime, _, _, _ := stealWork(now)
        if gp != nil {
            return gp, inheritTime, false
        }
    }
    return nil, false, false
}

五、协作式调度

除了抢占式调度，Go 还支持协作式调度。Goroutine 可以通过调用runtime.Gosched() 函数主动让出 CPU 的执行权。

func main() {
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println("Goroutine 1")
            runtime.Gosched()
        }
    }()
    for i := 0; i < 10; i++ {
        fmt.Println("Goroutine 2")
    }
}

六、总结

Go 语言的 Goroutine 调度机制通过 GMP 模型和 Work Stealing 算法实现了高效的并发执行。抢占式调度和协作式调度策略确保了 Goroutine 的公平执行，而 Work Stealing 算法则进一步提高了多核处理器上的负载均衡。通过这些机制，Go 运行时能够高效地利用系统资源，实现高性能的并发编程。