1. Go 并发模型概述：Goroutine 与 OS 线程对比、CSP 模型核心思想、并发与并行的区别

并发编程是 Go 语言的核心优势之一。本章从最基础的三个概念出发，帮助你建立对 Go 并发模型的正确认知：Goroutine 与 OS 线程的本质差异、CSP 模型的哲学，以及并发与并行的关键区别。这些是后续所有调优实战的基石。

1.1 并发 vs. 并行：两个容易混淆的概念

并发与并行经常被混用，但在系统设计和性能调优中，它们指向完全不同的能力。

维度 并发 (Concurrency) 并行 (Parallelism)
定义 逻辑上同时处理多个任务（任务交替执行） 物理上同时执行多个任务（真正的同时）
核心 任务调度与结构设计 硬件多核执行能力
硬件依赖 单核 CPU 即可实现 必须多核 CPU
Go 中的体现 Goroutine 的创建与调度 GOMAXPROCS 控制的工作线程数
典型比喻 一个人交替做多件事 多个人同时做各自的事
调优启示：并发是程序结构问题，并行是执行效率问题。先设计好并发结构，再通过调整 GOMAXPROCS 来利用并行能力。不要盲目增加并行度，否则可能因上下文切换反而降低性能。

1.2 Goroutine 与 OS 线程：轻量级与重量级的对决

Goroutine 是 Go 运行时管理的用户态“协程”，而 OS 线程是操作系统内核管理的调度单元。两者在创建成本、调度方式和内存占用上存在数量级的差异。

对比项 Goroutine OS 线程
初始栈大小 2 KB（可动态增长至 1 GB） 1 MB（固定，不可动态缩减）
创建/销毁成本 极低（约几百纳秒） 高（微秒级，涉及内核态切换）
调度方式 Go 运行时 M:N 调度（用户态） 内核抢占式调度
上下文切换 用户态，约 50 ns 内核态，约 1-10 μs
最大数量 百万级（理论值） 千级（受限于内存和内核表）
标识 goroutine ID（不推荐使用） 系统线程 ID
关键结论：Goroutine 的轻量特性使得 Go 程序可以轻松创建数十万甚至百万个并发任务，而不会像 OS 线程那样耗尽系统资源。这是 Go 高并发能力的根本来源。

1.3 CSP 模型核心思想：不要通过共享内存来通信

Go 的并发哲学源自 CSP（Communicating Sequential Processes，通信顺序进程）模型。CSP 的核心主张是：通过通信来共享内存，而不是通过共享内存来通信。

  • 实体独立：每个 Goroutine 是一个独立的执行体，拥有自己的栈和局部变量。
  • 通道通信：Goroutine 之间通过 channel 传递消息，而不是直接操作共享变量。
  • 同步保障：channel 的发送和接收操作天然同步，无需显式加锁。
  • 设计导向：程序员只需关注数据在 Goroutine 之间的流动路径，而非锁的竞争。
常见误区：CSP 模型并不禁止使用共享内存和互斥锁。在性能敏感或简单状态保护的场景下，sync.Mutex 仍然是高效的选择。CSP 提供的是更高层次的并发抽象，而非银弹。

1.4 Go 调度模型：M:N 调度与 G-P-M 架构

Go 运行时实现了 M:N 调度，即 M 个 Goroutine 映射到 N 个 OS 线程上执行。调度器由三个核心组件构成：

  • G（Goroutine）：代表一个待执行的任务，包含栈、指令指针、状态等信息。
  • P（Processor）：逻辑处理器，负责管理本地 Goroutine 队列。数量由 GOMAXPROCS 控制。
  • M（Machine）：OS 线程，负责实际执行 Goroutine 的机器码。

下图展示了 G-P-M 三者的协作关系：

Go 调度器 G-P-M 架构 Goroutine 池 (G) G1 (运行中) G2 (可运行) G3 (可运行) G4 (阻塞) G5 (可运行) 全局队列 + 本地队列 逻辑处理器 (P) P0 (GOMAXPROCS=4) P1 P2 P3 每个 P 维护本地 G 队列 数量 = GOMAXPROCS OS 线程 (M) M0 (运行 G1) M1 (空闲) M2 (系统调用) M3 (空闲) M 必须绑定 P 才能执行 G 数量由运行时动态管理 调度流程：G 入队 → P 从队列获取 G → M 绑定 P 并执行 G → G 阻塞/完成 → 循环

1.5 一个简单的并发示例

下面是一个使用 Goroutine 和 channel 实现 CSP 通信的典型代码：

package main

import (
    "fmt"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("Worker %d 开始处理任务 %d\n", id, j)
        time.Sleep(100 * time.Millisecond) // 模拟工作
        results <- j * 2
    }
}

func main() {
    const numJobs = 5
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    // 启动 3 个 Goroutine
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    // 发送任务
    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    // 收集结果
    for r := 1; r <= numJobs; r++ {
        <-results
    }
    fmt.Println("所有任务完成")
}
代码要点：
  • 3 个 Goroutine 并发从 jobs 通道读取任务，通过 results 通道返回结果。
  • 通道的阻塞特性天然实现了工作窃取和同步，无需额外加锁。
  • close(jobs) 后，Goroutine 通过 range 自动退出循环。

1.6 本章小结

  • 并发 vs. 并行：并发是结构，并行是执行。Go 通过 Goroutine 实现并发，通过 GOMAXPROCS 控制并行。
  • Goroutine vs. OS 线程：Goroutine 栈小、创建快、调度轻，支持百万级并发任务。
  • CSP 模型：通过 channel 通信来共享数据，避免共享内存带来的锁竞争和复杂性。
  • G-P-M 调度：Go 运行时通过 M:N 调度模型，将 Goroutine 高效映射到 OS 线程上执行。
← 上一章 📖 返回目录 下一章 →