1. Go 并发模型概述：从 CSP 理论到 Goroutine 的诞生

1.1 并发与并行：两个世界的分野

在深入 Go 的并发模型之前，必须厘清两个最容易被混淆的核心概念：并发（Concurrency）与并行（Parallelism）。Go 语言的创始人 Rob Pike 曾用一句经典的话概括二者的区别："Concurrency is about dealing with lots of things at once. Parallelism is about doing lots of things at once."

维度 并发（Concurrency） 并行（Parallelism）
核心关注点 任务的结构化分解与调度 任务的物理同时执行
执行方式 多个任务在时间片上交替执行（单核即可实现） 多个任务在多个核心上同时执行
硬件依赖 不依赖多核，单核 CPU 也能实现并发 必须依赖多核 CPU 或多处理器
本质 逻辑上的"同时"——任务调度与组合 物理上的"同时"——真正的并行计算
Go 中的体现 Goroutine 的创建与调度（G-M-P 模型） GOMAXPROCS 控制的工作线程并行度
关键认知：并发是一种程序设计范式，并行是一种执行状态。Go 通过 Goroutine 让开发者以并发的方式编写代码，运行时调度器则负责在可用核心上尽可能实现并行执行。

1.2 CSP 理论：通信顺序进程的哲学

Go 的并发模型并非凭空诞生，其理论根基来自 1978 年 Tony Hoare 提出的 CSP（Communicating Sequential Processes，通信顺序进程）理论。CSP 的核心思想可以概括为三条原则：

  • 进程独立：每个顺序进程拥有自己的状态和执行流，不共享内存。
  • 通信同步：进程之间通过通道（Channel）进行同步通信，而非通过共享变量。
  • 组合构建：通过组合多个通信进程来构建复杂系统。

与传统的共享内存并发模型（如 Java 的线程 + 锁）不同，CSP 倡导 "不要通过共享内存来通信，而应通过通信来共享内存"。这一哲学直接影响了 Go 语言的设计：Goroutine 之间通过 Channel 传递消息，从根本上减少了锁竞争和竞态条件的复杂度。

对比：传统共享内存模型（如 pthreads）中，线程间通过互斥锁保护临界区；CSP 模型中，Goroutine 通过 Channel 发送/接收数据，数据的所有权随通信转移，天然避免了数据竞争。

1.3 从线程到 Goroutine：轻量级并发的诞生

操作系统线程（OS Thread）是传统并发的基本单元，但其存在明显的性能瓶颈：

  • 创建成本高：线程创建需要分配内核栈（通常 1~8 MB），涉及系统调用。
  • 上下文切换代价大：线程切换需要保存/恢复 CPU 寄存器、刷新 TLB，耗时约 1~10 μs。
  • 数量受限：一个进程通常只能创建数千个线程，再多会导致调度器过载。

Go 语言为了解决这些问题，设计了 Goroutine——一种由 Go 运行时管理的用户态轻量级线程。Goroutine 与 OS 线程的关键差异如下：

特性 OS 线程 Goroutine
栈初始大小 1~8 MB（固定） 2~4 KB（动态伸缩）
创建成本 高（系统调用，微秒级） 极低（用户态分配，纳秒级）
上下文切换 内核态切换（1~10 μs） 用户态切换（约 100 ns）
调度器 操作系统内核调度 Go 运行时调度器（GMP）
最大数量 数千个 数百万个
注意：Goroutine 的轻量级并不意味着可以无限制创建。每个 Goroutine 至少占用 2~4 KB 栈空间，百万级 Goroutine 会消耗数 GB 内存。合理的并发设计应关注任务粒度，而非盲目追求 Goroutine 数量。

1.4 CSP 理论与 Goroutine 的映射关系

下图展示了 CSP 理论中的核心概念如何映射到 Go 语言的并发原语：

CSP 理论 → Go 并发原语映射 CSP 理论核心概念 顺序进程（Process） 独立执行流，拥有私有状态 通道（Channel） 进程间同步通信的媒介 组合（Composition） 通过通信组合构建复杂系统 Go 语言并发原语 Goroutine 用户态轻量级线程（go 关键字） Channel 带类型的管道（chan T） select + goroutine 多路复用与组合模式 CSP 理论为 Go 并发提供了设计蓝图，Goroutine + Channel 是其工程实现

1.5 Goroutine 的诞生：从 go 关键字开始

在 Go 中，创建一个 Goroutine 只需要在函数调用前加上 go 关键字：

package main

import (
    "fmt"
    "time"
)

func sayHello() {
    fmt.Println("Hello from goroutine")
}

func main() {
    // 启动一个 Goroutine 执行 sayHello 函数
    go sayHello()

    // 主 Goroutine 继续执行
    fmt.Println("Hello from main")

    // 等待子 Goroutine 执行完毕（仅用于演示）
    time.Sleep(100 * time.Millisecond)
}

这段代码背后发生了什么？

  1. Goroutine 创建：go sayHello() 调用时，Go 运行时在堆上分配一个 g 结构体（约 4 KB 初始栈），将其状态标记为 _Grunnable。
  2. 入队等待：新创建的 Goroutine 被放入当前 P（Processor）的本地运行队列（LRQ）中，等待调度。
  3. 调度执行：当某个 M（Machine，即 OS 线程）空闲时，调度器从 LRQ 中取出 Goroutine，将其绑定到 M 上执行。
  4. 栈动态伸缩：如果 Goroutine 的栈空间不足，运行时通过 stackalloc 机制动态扩容（初始 2~4 KB，最大可达 1 GB）。
性能数据：创建一个 Goroutine 仅需分配约 4 KB 栈空间和少量元数据，耗时约 100~200 ns；而创建一个 OS 线程需要分配 1~8 MB 栈空间并触发系统调用，耗时约 1~10 μs。这意味着 Goroutine 的创建成本比线程低 2~3 个数量级。

1.6 并发模型演进：从裸线程到 GMP

Go 的并发模型经历了三个阶段的演进，最终形成了今天的 GMP 架构：

阶段 模型 核心问题 解决方案
Go 1.0 GM 模型（Goroutine + 全局队列） 全局互斥锁竞争严重，调度性能差 引入 P（Processor）作为中间层
Go 1.1 GMP 模型（Goroutine + Machine + Processor） 本地队列减少锁竞争，工作窃取提高负载均衡 每个 P 拥有本地运行队列
Go 1.14+ 异步抢占式调度 长时间运行的 Goroutine 阻塞其他 Goroutine 基于信号量的异步抢占机制

下图展示了 GM 模型与 GMP 模型的核心差异：

GM 模型 vs GMP 模型：调度架构对比 GM 模型（Go 1.0） 全局运行队列（GRQ） 全局互斥锁保护 M1 直接取 G → M2 直接取 G 瓶颈：全局锁竞争激烈 GMP 模型（Go 1.1+） P1 本地队列 → P2 本地队列 无锁或局部锁操作 工作窃取（Work Stealing） 优势：高并发低锁争用

1.7 本章小结

  • 并发 ≠ 并行：并发是程序设计的结构属性，并行是执行时的物理属性。Go 通过 GMP 模型在单核上实现并发，在多核上实现并行。
  • CSP 理论是 Go 并发设计的灵魂：Goroutine 对应 CSP 中的顺序进程，Channel 对应通信通道，select 对应组合机制。
  • Goroutine 是轻量级线程：其栈初始仅 2~4 KB，创建成本比 OS 线程低 2~3 个数量级，支持百万级并发。
  • GMP 模型解决了 GM 模型的全局锁瓶颈：通过引入 P 层实现本地队列和工作窃取，大幅提升调度效率。
← 上一章 📖 返回目录 下一章 →