一、什么是并发模型?
并发模型(Concurrency Model)是编程语言或运行时组织多个任务执行、协调任务之间关系的一套机制。
它主要解决以下问题:
- 如何同时管理多个任务?
- 如何分配 CPU 执行时间?
- 如何处理 I/O 等待?
- 如何在任务之间传递数据?
- 如何避免共享状态冲突?
- 如何控制任务的生命周期?
- 如何处理任务取消、超时和异常?
并发与并行并不是同一个概念。
并发(Concurrency)关注多个任务在时间上的交替推进,强调任务组织与协调。
并行(Parallelism)关注多个任务在同一时刻利用不同执行资源运行,强调实际同时执行。
例如,一个单线程事件循环可以并发处理大量网络请求,但在同一时刻通常只有一个 JavaScript 回调在该线程上执行。
而多个 CPU 核心可以并行执行不同线程中的计算任务。
flowchart TD
A["多个任务"] --> B{"执行方式"}
B --> C["并发"]
B --> D["并行"]
C --> E["任务交替推进"]
C --> F["等待期间切换其他任务"]
D --> G["多个执行单元同时运行"]
D --> H["利用多核 CPU"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#FFF5DE,stroke:#E8D29A,color:#334155
style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style H fill:#F3EDFC,stroke:#C4B2E3,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
1. 并发模型的核心组成
一个完整的并发模型通常涉及以下几个部分:
| 组成部分 | 作用 |
|---|---|
| 执行单元 | 表示可以独立推进的任务,如线程、协程 |
| 调度器 | 决定任务何时获得执行机会 |
| 同步机制 | 协调任务之间的执行顺序 |
| 通信机制 | 在任务之间传递数据 |
| 状态管理 | 管理任务共享或独立的数据 |
| 生命周期管理 | 处理启动、等待、取消和结束 |
| 异常传播 | 定义任务失败如何影响其他任务 |
不同语言的并发模型,主要区别在于这些组成部分如何实现,以及语言和运行时为开发者提供了什么抽象。
二、并发模型的主要类型
从任务组织方式和通信机制来看,常见并发模型包括:
- 基于线程的并发模型。
- 基于事件循环的并发模型。
- 基于协程的并发模型。
- 基于 Actor 的并发模型。
- 基于消息传递的并发模型。
- 基于数据并行的并发模型。
这些模型并不完全互斥。
例如,Go 同时使用 goroutine、调度器和 channel;Java 同时支持线程、虚拟线程、线程池和异步任务;Rust 可以组合线程、异步 Future 和消息通道。
三、基于线程的并发模型
线程(Thread)是操作系统和运行时中常见的执行单元。
线程通常拥有独立的执行栈、寄存器上下文等执行状态,同一进程中的线程可以共享进程地址空间。
1. 基本原理
在基于线程的并发模型中,程序通过创建多个线程执行不同任务。
例如:
public class Main {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
System.out.println("Task A");
});
Thread t2 = new Thread(() -> {
System.out.println("Task B");
});
t1.start();
t2.start();
}
}
两个线程可以由操作系统调度执行。
如果系统拥有多个可用 CPU 核心,它们也可能真正并行运行。
flowchart TD
A["主程序"] --> B["创建线程"]
B --> C["线程 A"]
B --> D["线程 B"]
B --> E["线程 C"]
C --> F["操作系统调度"]
D --> F
E --> F
F --> G["CPU 核心执行"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
2. 线程模型的特点
优点:
- 可以充分利用多核 CPU。
- 适合 CPU 密集型并行计算。
- 能够使用操作系统提供的线程调度能力。
- 多线程生态成熟,工具和库丰富。
缺点:
- 创建和销毁线程存在成本。
- 线程上下文切换可能带来开销。
- 共享内存需要同步。
- 可能发生竞态条件、死锁和数据竞争。
- 大量线程会增加内存与调度压力。
3. 共享内存与同步
线程通常可以访问同一进程中的共享数据。
例如:
class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public int getCount() {
return count;
}
}
这里使用 synchronized 保证递增操作在互斥锁保护下执行。
如果多个线程同时访问共享状态,却没有正确同步,就可能出现数据竞争或竞态条件。
线程模型的核心难点不在于创建线程,而在于管理共享状态和执行顺序。
4. 线程池
频繁创建线程会产生额外开销,因此实际项目通常使用线程池。
线程池预先创建或按需创建一定数量的工作线程,后续任务提交给线程池,由工作线程重复执行。
flowchart TD
A["业务提交任务"] --> B["任务队列"]
B --> C["线程池"]
C --> D["工作线程 A"]
C --> E["工作线程 B"]
C --> F["工作线程 C"]
D --> G["执行任务"]
E --> G
F --> G
G --> H["返回结果"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
线程池可以减少线程创建开销,但并不意味着线程数量越多越好。
线程数量需要结合 CPU 核心数、任务类型、阻塞时间、队列长度和资源限制进行配置。
四、基于事件循环的并发模型
事件循环(Event Loop)是一种通过事件队列和任务调度实现并发的机制。
它通常由一个循环持续检查可执行任务,并在适当时机执行回调。
JavaScript 是这种模型的典型应用。
1. 基本原理
事件循环的核心思想是:
- 当前任务执行时,不会因为普通异步 I/O 等待而一直占用执行线程。
- 异步操作由运行时或宿主环境处理。
- 操作完成后,将后续任务安排到相应队列。
- 事件循环在合适时机执行这些任务。
例如:
console.log("Start");
setTimeout(() => {
console.log("Timer");
}, 1000);
console.log("End");
输出顺序:
Start
End
Timer
setTimeout 不会阻塞后续同步代码执行。
2. 事件循环的基本结构
以浏览器 JavaScript 为例,事件循环涉及:
- 调用栈。
- 宏任务及相关任务队列。
- 微任务队列。
- 宿主环境提供的异步能力。
- 渲染更新时机。
一个简化的执行过程:
flowchart TD
A["执行当前任务"] --> B["同步代码运行"]
B --> C["调用异步 API"]
C --> D["宿主环境处理异步操作"]
D --> E["异步任务完成"]
E --> F["安排回调任务"]
F --> G["当前任务结束"]
G --> H["检查微任务队列"]
H --> I["执行微任务"]
I --> J["进入下一轮事件循环"]
J --> A
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
style I fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style J fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
注意:这是便于理解的简化模型。浏览器事件循环、Node.js 事件循环和其他 JavaScript 宿主环境在任务队列、阶段和调度细节上并不完全相同。
3. 事件循环的优点
- 适合大量 I/O 密集型任务。
- 减少大量操作系统线程的管理开销。
- 可以通过异步回调组织任务。
- 对共享状态的管理相对简单。
- 适合网络服务和交互式应用。
4. 事件循环的局限
事件循环通常依赖单个执行线程完成回调任务。
如果某个回调执行大量 CPU 密集型计算,就可能长时间占用事件循环。
例如:
function heavyTask() {
let result = 0;
for (let i = 0; i < 1000000000; i++) {
result += i;
}
return result;
}
heavyTask();
如果在主事件循环线程中直接执行这类任务,其他回调就可能无法及时运行。
常见解决方式:
- 将计算任务交给 Worker。
- 使用线程池。
- 将计算拆分为多个较小任务。
- 将计算放到独立进程或服务中。
五、基于协程的并发模型
协程(Coroutine)是一种可以暂停和恢复执行的程序执行单元。
与传统线程相比,协程通常具有更轻量的执行上下文,可以由语言运行时或协程库调度。
1. 协程的基本原理
协程允许函数在执行过程中暂停,并在后续条件满足时恢复执行。
例如 Python:
import asyncio
async def task(name):
print(name, "开始")
await asyncio.sleep(1)
print(name, "结束")
async def main():
await asyncio.gather(
task("A"),
task("B")
)
asyncio.run(main())
两个协程都执行到 await 时,会挂起等待。
事件循环可以安排其他可运行协程继续执行。
2. 协程的调度过程
flowchart TD
A["创建协程"] --> B["提交给调度器"]
B --> C["协程开始运行"]
C --> D{"是否遇到挂起点"}
D -->|否| C
D -->|是| E["保存协程执行状态"]
E --> F["等待异步操作"]
F --> G["等待条件满足"]
G --> H["重新进入可运行队列"]
H --> I["恢复协程执行"]
I --> C
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style I fill:#F3EDFC,stroke:#C4B2E3,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
3. 协程的优点
- 通常比大量操作系统线程更轻量。
- 可以用同步风格的代码表达异步逻辑。
- 适合高并发 I/O 场景。
- 可以减少显式回调嵌套。
- 任务暂停和恢复机制比较灵活。
4. 协程的局限
- 需要理解挂起和恢复机制。
- 协程调度器可能增加运行时复杂度。
- 阻塞调用可能阻塞底层执行线程。
- 协程数量仍然受到内存和调度资源限制。
- 不同语言的协程实现差异很大。
特别注意:
协程轻量,不代表协程天然具备 CPU 并行能力。
例如,Python 的 asyncio 通常由一个事件循环线程调度协程。它擅长 I/O 并发,但不会自动将 CPU 密集型任务分配到多个 CPU 核心。
六、基于 Actor 的并发模型
Actor 模型是一种以独立实体为核心的并发模型。
每个 Actor 通常拥有:
- 私有状态。
- 消息邮箱。
- 消息处理逻辑。
- 创建其他 Actor 的能力。
- 向其他 Actor 发送消息的能力。
Actor 之间不直接共享可变状态,而是通过消息传递进行协作。
1. 基本原理
假设一个电商系统包含:
- 用户 Actor。
- 订单 Actor。
- 库存 Actor。
- 支付 Actor。
每个 Actor 负责自己的状态和业务逻辑。
例如:
用户请求下单
订单 Actor 创建订单
库存 Actor 检查库存
支付 Actor 处理付款
Actor 不需要直接操作其他 Actor 的内部数据,而是通过消息交互。
2. Actor 的工作流程
flowchart TD
A["外部请求"] --> B["订单 Actor"]
B --> C["发送库存检查消息"]
C --> D["库存 Actor"]
D --> E["返回库存结果"]
E --> F["订单 Actor"]
F --> G["发送支付消息"]
G --> H["支付 Actor"]
H --> I["返回支付结果"]
I --> J["订单状态更新"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style I fill:#FFF5DE,stroke:#E8D29A,color:#334155
style J fill:#E5F4EC,stroke:#A3CBB5,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
3. Actor 模型的优点
- 通过消息传递降低共享状态问题。
- 每个 Actor 可以独立维护内部状态。
- 适合分布式系统和高并发业务。
- 可以通过监督策略处理任务失败。
- 便于将系统拆分为独立业务单元。
4. Actor 模型的局限
- 消息传递会产生序列化和调度成本。
- 消息顺序与处理保证需要明确设计。
- 消息丢失、重复和超时需要处理。
- 跨 Actor 的事务协调比较复杂。
- 调试异步消息链路存在一定难度。
Actor 模型并不意味着一定没有并行。
具体 Actor 实现可以使用多个线程执行不同 Actor,也可以将 Actor 分配到多个进程或节点。
七、基于消息传递的并发模型
消息传递(Message Passing)是多个执行单元之间交换数据和协调工作的方式。
它强调通过发送和接收消息完成协作,而不是直接访问共享内存。
常见实现:
- Channel。
- 消息队列。
- 进程间通信。
- Actor 邮箱。
- 分布式消息系统。
1. 消息传递的基本模式
例如 Go:
package main
import "fmt"
func worker(ch chan string) {
ch <- "任务完成"
}
func main() {
ch := make(chan string)
go worker(ch)
result := <-ch
fmt.Println(result)
}
这里:
ch <- "任务完成"表示发送消息。<-ch表示接收消息。- Channel 用于在 goroutine 之间传递数据。
2. 消息传递的类型
| 类型 | 特点 | 常见用途 |
|---|---|---|
| 同步消息 | 发送和接收需要协调 | 任务交接、请求响应 |
| 异步消息 | 发送方不必等待接收方处理完成 | 解耦业务、后台任务 |
| 有界队列 | 队列容量有限 | 背压和资源控制 |
| 无界队列 | 理论上可持续接收消息 | 需要额外控制内存增长 |
| 点对点消息 | 一个消息由一个消费者处理 | 任务分发 |
| 发布订阅 | 一个消息可以被多个订阅者接收 | 事件通知 |
3. 消息传递的优势
- 降低共享内存的耦合。
- 便于拆分并发任务。
- 可以通过队列实现流量缓冲。
- 有助于构建分布式系统。
- 方便引入背压和限流机制。
但消息传递不意味着完全没有共享状态。
同一进程中的 Channel 可能传递指针或对象引用;如果多个任务仍然访问同一可变对象,就仍然需要考虑数据竞争。
八、Go 的并发模型:Goroutine 与 Channel
Go 的并发模型具有代表性。
它结合了轻量级 goroutine、Channel 和运行时调度器。
1. Goroutine
Goroutine 是由 Go 运行时管理的轻量级执行单元。
示例:
package main
import (
"fmt"
"time"
)
func sayHello() {
fmt.Println("Hello")
}
func main() {
go sayHello()
time.Sleep(time.Second)
}
使用 go 关键字可以启动一个新的 goroutine。
与传统操作系统线程相比,goroutine 的创建和切换通常更加轻量。
2. G-M-P 调度模型
Go 运行时使用 G-M-P 模型组织 goroutine 调度。
- G:Goroutine,表示待执行的任务。
- M:Machine,表示操作系统线程。
- P:Processor,表示执行 Go 代码所需的调度资源。
P 负责维护可运行的 G,并将 G 调度到 M 上执行。
flowchart TD
A["Goroutine G"] --> B["P 调度器"]
B --> C["本地运行队列"]
C --> D["M 操作系统线程"]
D --> E["CPU 执行"]
F["全局运行队列"] --> B
G["其他 P"] --> H["工作窃取"]
H --> C
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style H fill:#F3EDFC,stroke:#C4B2E3,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px