第 16/41 课 · 并发编程核心 m03-l01

并发模型：Goroutine 与 GMP 调度器

本课所属：第三模块：并发编程｜课时：m03-l01 ｜难度：进阶学完本课你将能够：理解 Go 语言轻量级并发原语 goroutine 的设计哲学，掌握 GMP 调度器的工作原理，并能通过 GOMAXPROCS 控制程序的并行度。

一、学习目标

能解释 goroutine 与操作系统线程的区别，并说明其轻量级特性。
能描述 G、M、P 三个核心组件的角色及其协作关系。
能解释 GMP 调度器中的 work stealing 机制及 hand off 场景。
能使用 GOMAXPROCS 控制并发度，并理解 Go 1.22 循环变量语义的变化。

二、知识讲解

1.1 并发与并行：goroutine 的轻量级设计

并发（Concurrency）是指程序处理多个任务的能力，而并行（Parallelism）是指同时执行多个任务的能力。Go 语言通过 goroutine 实现了高效的并发。

goroutine 是 Go 运行时（runtime）管理的轻量级线程。与操作系统线程（OS Thread）不同，goroutine 的初始栈大小仅为 2KB，并根据需要动态增长。在 64 位平台上，单个 goroutine 的栈上限默认为 1GB，32 位平台为 250MB。这种设计使得我们可以轻松创建数百万个 goroutine，而不会耗尽系统内存。

为什么这样设计？ 在传统的线程模型中，创建线程的开销较大（通常涉及内核态切换和较大的栈分配）。Go 语言将线程调度从内核态移到了用户态（由 Go runtime 调度），从而极大地降低了并发开销。

1.2 GMP 调度模型

Go 的运行时调度器使用 GMP 模型来管理并发任务。理解 GMP 是掌握 Go 并发编程的核心。

G (Goroutine)：代表一个 goroutine，包含其执行状态、栈空间、指令指针等信息。它是调度的基本单位。
M (Machine)：代表一个操作系统线程（OS Thread）。M 是实际执行 Go 代码的载体。
P (Processor)：代表逻辑处理器，可以理解为执行许可（Execution Permit）。M 必须持有 P 才能执行 Go 代码。P 的数量由 GOMAXPROCS 决定。

P 的核心作用： 1. 执行许可：一个 M 只有在绑定 P 之后才能运行 G。因此，同一时刻真正并行的 G 数不超过 GOMAXPROCS。 2. 资源管理：P 持有本地运行队列（无锁，容量 256）和 mcache 等运行时资源。 3. 调度优化：当 G 发起阻塞系统调用（如 I/O、cgo）时，M 会释放 P（称为 hand off），让其他 M 接管这个 P 继续跑队列里的 G，避免整个调度器被一个系统调用卡死。而 channel、Mutex 等用户态阻塞只是把 G 挂起（park），M 并不移交 P。

Work Stealing（工作窃取）： 当某个 P 的本地队列为空时，它会尝试从其他 P 的本地队列中“窃取”一半的 G 来执行，或者从全局队列中获取 G。这种负载均衡机制称为 work stealing，能有效提高多核 CPU 的利用率。

1.3 GOMAXPROCS 与并行度

GOMAXPROCS 设置的是逻辑处理器 P 的数量，也就是同一时刻能执行 Go 代码的最大 M 数量。M 的总数不受此上限约束（例如大量阻塞在系统调用、cgo 或 LockOSThread 时会创建更多 M）。

自 Go 1.5 起，GOMAXPROCS 的默认值就是 runtime.NumCPU()，通常无需显式设置。仅在程序或被依赖的库修改过该值、或部署环境需要限核（如容器 CPU quota 场景）时才显式设置。

注意： GOMAXPROCS 限制的是并行执行的 Go 代码数量，而非 goroutine 的总数。休眠中的 G 不占用 P，因此 time.Sleep 不会影响并行度。

1.4 Go 1.22 循环变量语义变更

Go 1.22 起，for 循环（包括 3 段式循环和 range 循环）每次迭代都会创建新的循环变量。这意味着闭包捕获的是每次迭代的新变量，而非共享的旧变量。该变更依据模块 go.mod 的 go 指令生效。在 Go 1.21 及更早版本中，循环变量在整个循环中只有一个实例，闭包捕获的是同一个变量，这曾是经典的并发陷阱。

三、示例代码

示例 1：Goroutine 基础与生命周期

本示例演示如何启动 goroutine，并说明主协程退出会导致所有 goroutine 终止。

package main

import (
    "fmt"
    "time"
)

func worker(id int) {
    fmt.Printf("Worker %d 开始\n", id)
    // 模拟工作
    time.Sleep(100 * time.Millisecond)
    fmt.Printf("Worker %d 完成\n", id)
}

func main() {
    // 启动 3 个 goroutine
    for i := 0; i < 3; i++ {
        go worker(i)
    }

    // 主协程等待，否则主协程退出后所有 goroutine 会被强制终止
    // 在实际工程中，建议使用 sync.WaitGroup
    time.Sleep(200 * time.Millisecond)
    fmt.Println("所有任务完成，程序正常退出")
}

运行结果（预期输出）：

Worker 0 开始
Worker 1 开始
Worker 2 开始
Worker 0 完成
Worker 1 完成
Worker 2 完成
所有任务完成，程序正常退出

(注：Worker 开始和完成的顺序可能因调度而不同，但每个 Worker 都会执行)

示例 2：GOMAXPROCS 与并行度演示

本示例演示 GOMAXPROCS 如何影响 CPU 密集型任务的并行度。注意：这里使用 CPU 忙等任务，而非 time.Sleep，因为休眠不占用 P。

package main

import (
    "fmt"
    "runtime"
    "time"
)

// cpuWork 模拟 CPU 密集型任务
func cpuWork(id int, duration time.Duration) {
    start := time.Now()
    // 简单的 CPU 忙等，确保占用 P
    for i := 0; i < 100000000; i++ {
        _ = i * i
    }
    elapsed := time.Since(start)
    fmt.Printf("Task %d 完成 (耗时: %v, GOMAXPROCS: %d)\n", id, elapsed, runtime.GOMAXPROCS(0))
}

func main() {
    // 设置 GOMAXPROCS 为 2
    runtime.GOMAXPROCS(2)
    fmt.Printf("当前机器逻辑 CPU 数量: %d, 设置 GOMAXPROCS: 2\n", runtime.NumCPU())

    // 启动 4 个 CPU 密集型任务
    for i := 0; i < 4; i++ {
        go cpuWork(i, 0)
    }

    // 等待所有任务完成
    // 由于没有 WaitGroup，这里使用简单的 sleep 等待，实际工程中应使用 WaitGroup
    time.Sleep(2 * time.Second)
}

运行结果（预期输出）：

当前机器逻辑 CPU 数量: 4, 设置 GOMAXPROCS: 2
Task 0 完成 (耗时: 150ms, GOMAXPROCS: 2)
Task 1 完成 (耗时: 150ms, GOMAXPROCS: 2)
Task 2 完成 (耗时: 150ms, GOMAXPROCS: 2)
Task 3 完成 (耗时: 150ms, GOMAXPROCS: 2)

(注：任务完成顺序不确定；耗时因机器性能而异，但总耗时约为单任务耗时的 ceil(4/2)=2 倍)

四、常见错误与避坑指南

错误认知：goroutine 就是操作系统线程
原因：goroutine 是 Go runtime 管理的用户态线程，数量远多于 OS 线程。
正确做法：理解 GMP 模型，goroutine 是逻辑任务，OS 线程是物理执行载体。
错误写法：依赖 time.Sleep 等待 goroutine 完成
原因：time.Sleep 时间难以精确控制，可能导致输出不完整或程序挂起。
正确做法：使用 sync.WaitGroup 或 channel 进行同步。
错误写法：Go 1.21 及更早版本中闭包捕获循环变量
原因：在 Go 1.21 及更早版本中，for i := 0; i < 10; i++ 中的 i 只有一个实例，所有 goroutine 共享同一个 i，导致输出混乱。
正确做法：Go 1.22 起此问题已解决。若需兼容旧版本，应将变量作为参数传入 goroutine：go func(i int) { ... }(i)。

五、最佳实践

使用 sync.WaitGroup 等待 goroutine 完成：避免使用 time.Sleep，确保程序正确同步。
合理设置 GOMAXPROCS：默认值已是 runtime.NumCPU()，通常无需设置；仅在容器限核或特殊场景下显式设置。
避免在 goroutine 中捕获循环变量：虽然 Go 1.22 已修复，但显式传参仍是更清晰、跨版本安全的写法。
注意 goroutine 泄漏：确保 goroutine 能正常退出，避免资源泄漏。

六、练习题

概念题：简述 GMP 调度模型中 P 的作用，并解释为什么 GOMAXPROCS 限制的是并行度而非 goroutine 数量。
编码题：编写一个程序，启动 10 个 goroutine，每个 goroutine 打印自己的编号（0-9），并使用 sync.WaitGroup 确保主协程等待所有 goroutine 完成后再退出。要求输出包含每个 goroutine 的编号，顺序不限。
进阶/调试题：以下代码在 Go 1.21 及更早版本中运行，输出结果可能不符合预期。请指出问题所在，并给出修复后的代码，使其在所有版本中都输出 0 到 9 各一次（顺序不限）。 ```go package main

import ( "fmt" "time" )

func main() { for i := 0; i < 10; i++ { go func() { fmt.Println(i) }() } time.Sleep(1 * time.Second) } ```

七、练习参考答案

参考答案（点击展开 / 收起）

第 1 题

P 是执行许可，M 必须持有 P 才能执行 Go 代码。GOMAXPROCS 设置 P 的数量，因此限制了同一时刻能执行 Go 代码的 M 数量，即并行度。goroutine 数量可以远大于 GOMAXPROCS，因为它们可以在同一个 M 上分时执行。

第 2 题

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            fmt.Println(id)
        }(i)
    }
    wg.Wait()
}

说明：使用 sync.WaitGroup 等待所有 goroutine 完成。将 i 作为参数传入 goroutine，确保每个 goroutine 捕获自己的编号。

第 3 题

问题所在：在 Go 1.21 及更早版本中，for 循环中的 i 只有一个实例，所有 goroutine 共享同一个 i。当 goroutine 执行 fmt.Println(i) 时，i 的值可能已经变为 10，导致输出全是 10 或混乱。

修复后的代码：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        // 将 i 作为参数传入，确保每个 goroutine 捕获自己的副本
        go func(id int) {
            defer wg.Done()
            fmt.Println(id)
        }(i)
    }
    wg.Wait()
}

说明：通过显式传参 func(id int)，每个 goroutine 获得自己的 id 副本。在 Go 1.22 及更高版本中，即使不传参，每次迭代的 i 也是新变量，但传参仍是跨版本安全的最佳实践。同时使用 sync.WaitGroup 确保输出完整。

八、本课小结

goroutine 是轻量级并发原语，初始栈 2KB，动态增长。
GMP 调度模型中，P 是执行许可，M 是 OS 线程，G 是 goroutine。
GOMAXPROCS 控制并行度，默认值为 runtime.NumCPU()。
Go 1.22 起，for 循环每次迭代创建新变量，解决了闭包捕获循环变量的经典陷阱。
下一课预告：通道（Channel）：goroutine 间通信的安全方式。