一、什么是并发与并行
并发(Concurrency)和并行(Parallelism)是两个密切相关但含义不同的概念。
1. 并发(Concurrency)
并发是指系统在同一时间段内处理多个任务的能力。
多个任务可以在逻辑上同时推进,但不一定在物理时间上同时执行。
例如,单核 CPU 可以通过任务切换执行多个任务:
- 任务 A 执行一段时间。
- 操作系统保存任务 A 的执行状态。
- CPU 切换到任务 B。
- 任务 B 执行一段时间。
- CPU 再切换回任务 A。
从系统整体来看,多个任务都在推进,因此具备并发能力。
并发关注的是:
- 多个任务如何组织。
- 任务如何交替执行。
- 如何处理任务之间的依赖。
- 如何共享资源。
- 如何协调任务的执行顺序。
2. 并行(Parallelism)
并行是指多个任务在同一时刻真正执行。
例如,一台具有 8 个物理核心的 CPU,可以让多个线程在不同核心上同时运行。
如果任务之间没有依赖关系,就可以将它们分配到不同核心执行。
并行关注的是:
- 多个任务如何同时运行。
- 如何分配计算资源。
- 如何减少任务执行时间。
- 如何平衡不同处理单元的负载。
- 如何处理并行执行中的数据竞争。
3. 并发与并行的核心区别
| 对比维度 | 并发(Concurrency) | 并行(Parallelism) |
|---|---|---|
| 核心目标 | 管理多个任务的推进 | 同时执行多个任务 |
| 时间关系 | 同一时间段内交替推进或重叠 | 同一时刻执行 |
| CPU 要求 | 单核也可以实现 | 通常需要多个执行处理单元 |
| 关注重点 | 任务组织、协调与调度 | 计算资源分配与执行效率 |
| 典型应用 | 网络服务、异步 I/O、任务调度 | 图像处理、矩阵计算、科学计算 |
| 主要挑战 | 竞态条件、死锁、状态协调 | 数据竞争、负载均衡、同步开销 |
需要注意:并发和并行不是互斥关系。
一个程序可以:
- 只有并发,没有并行。
- 同时具备并发与并行。
- 在某个阶段并发,在另一个阶段并行。
二、并发与并行的执行模型
1. 单核并发
单核 CPU 同一时刻通常只能执行一个普通指令流,但操作系统可以通过时间片调度,让多个任务交替执行。
flowchart TB
A["CPU 单核心"] --> B["调度器"]
B --> C["任务 A"]
B --> D["任务 B"]
B --> E["任务 C"]
C --> F["时间片切换"]
D --> F
E --> F
F --> B
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:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
从时间轴来看:
时间 ─────────────────────────────────>
CPU: A A A | B B B | C C | A A | B B
A、B、C 并没有在同一时刻执行,而是通过 CPU 时间片交替推进。
这就是单核并发。
2. 多核并行
多核 CPU 可以将不同任务分配给不同核心,让它们在同一时刻执行。
flowchart TB
A["任务集合"] --> B["任务调度"]
B --> C["CPU 核心 1"]
B --> D["CPU 核心 2"]
B --> E["CPU 核心 3"]
B --> F["CPU 核心 4"]
C --> G["任务 A 同时执行"]
D --> H["任务 B 同时执行"]
E --> I["任务 C 同时执行"]
F --> J["任务 D 同时执行"]
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:#E5F4EC,stroke:#A3CBB5,color:#334155
style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
style I fill:#FFF5DE,stroke:#E8D29A,color:#334155
style J fill:#FFF5DE,stroke:#E8D29A,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
多核并行的执行时间轴:
时间 ─────────────────────────────────>
核心 1: A A A A A A A A
核心 2: B B B B B B B B
核心 3: C C C C C C C C
核心 4: D D D D D D D D
多个核心可以真正同时执行不同任务。
3. 并发与并行的组合
在真实系统中,并发与并行通常同时存在。
例如,一个 Web 服务可能同时处理数千个请求:
- 请求之间具有并发关系。
- CPU 密集型任务可以分配到不同核心并行执行。
- I/O 操作可以通过异步机制等待外部资源。
- 操作系统负责线程调度和处理器资源分配。
因此,并发描述程序的任务组织方式,并行描述任务的实际执行方式。
三、进程、线程与协程
并发与并行的实现通常涉及进程、线程和协程。
它们处于不同抽象层次,不能简单等同。
1. 进程(Process)
进程是操作系统进行资源分配和管理的重要单位。
一个进程通常拥有独立的虚拟地址空间,以及相关的系统资源。
进程通常包含:
- 虚拟内存空间。
- 代码段。
- 数据段。
- 堆。
- 线程。
- 文件描述符或句柄。
- 其他操作系统资源。
不同进程之间通常通过进程间通信(IPC)交换数据。
常见通信方式:
- 管道(Pipe)。
- 消息队列(Message Queue)。
- 共享内存(Shared Memory)。
- Socket。
- 信号(Signal)。
进程之间具有相对独立的资源边界,但进程创建、切换和通信通常存在一定开销。
2. 线程(Thread)
线程是操作系统调度执行的重要单位。
同一进程内的多个线程通常共享:
- 进程地址空间。
- 堆内存。
- 全局变量。
- 静态数据。
- 文件描述符等进程资源。
每个线程拥有独立的执行上下文,通常包括:
- 程序计数器。
- 寄存器状态。
- 栈。
- 线程局部存储(TLS)。
- 调度状态。
线程共享地址空间,使线程之间的数据交换更加方便,但也带来了同步和数据竞争问题。
3. 协程(Coroutine)
协程是一种可以暂停和恢复执行的程序执行单元。
协程通常由语言运行时、协程库或框架进行调度。
协程可以在执行过程中挂起,保存必要的执行状态,之后再从挂起位置恢复。
例如:
import asyncio
async def task_a():
print("任务 A 开始")
await asyncio.sleep(1)
print("任务 A 结束")
async def task_b():
print("任务 B 开始")
await asyncio.sleep(1)
print("任务 B 结束")
async def main():
await asyncio.gather(task_a(), task_b())
asyncio.run(main())
在这个例子中,两个协程通过事件循环交替推进。
当一个协程等待异步操作时,事件循环可以调度另一个协程执行。
需要注意:
- 协程不一定由操作系统直接调度。
- 协程不一定对应独立线程。
- 单线程协程可以实现高并发 I/O。
- 协程只有在多个执行线程或处理核心上运行时,才可能获得真正的并行执行。
4. 进程、线程与协程对比
| 对比维度 | 进程 | 线程 | 协程 |
|---|---|---|---|
| 抽象层次 | 操作系统资源管理 | 操作系统执行单元 | 程序执行单元 |
| 资源空间 | 通常独立地址空间 | 同进程线程共享地址空间 | 取决于所属线程和运行时 |
| 调度主体 | 操作系统 | 通常由操作系统调度 | 语言运行时或协程调度器 |
| 切换开销 | 通常较高 | 通常低于进程切换 | 通常较低,但依实现而定 |
| 数据共享 | 需要 IPC 或共享内存 | 可直接共享进程数据 | 可共享所属线程可访问的数据 |
| 并发能力 | 支持 | 支持 | 支持 |
| 并行能力 | 多进程可并行 | 多线程可并行 | 取决于调度器和执行线程 |
需要注意,现代系统中存在用户态线程、M:N 线程模型、绿色线程等实现,不能仅凭“线程”或“协程”的名称判断其调度方式。
四、并发的核心机制
并发程序不仅需要创建多个任务,还需要管理它们的执行状态和资源访问。
1. 上下文切换(Context Switching)
上下文切换是处理器从一个执行任务切换到另一个执行任务的过程。
切换时,系统需要保存当前任务的执行状态,并恢复目标任务的执行状态。
通常涉及:
- 寄存器状态。
- 程序计数器。
- 栈指针。
- 调度信息。
- 地址空间相关状态(视切换类型而定)。
线程上下文切换可能发生在:
- 时间片耗尽。
- 线程主动阻塞。
- 等待 I/O。
- 等待锁。
- 更高优先级任务就绪。
- 主动让出 CPU。
上下文切换存在成本:
- 保存和恢复寄存器。
- 调度器运行。
- 缓存局部性受到影响。
- 可能产生 TLB 和缓存相关开销。
- 线程过多时增加系统调度压力。
因此,线程数量并不是越多越好。
2. 线程调度(Thread Scheduling)
线程调度负责决定哪个就绪线程获得 CPU 执行机会。
常见调度策略包括:
- 先来先服务(FCFS)。
- 时间片轮转(Round Robin)。
- 优先级调度。
- 多级反馈队列。
- 公平调度。
现代操作系统通常采用更复杂的调度策略,并综合考虑优先级、公平性、处理器亲和性和负载情况。
调度过程可以抽象为:
flowchart TB
A["线程创建"] --> B["就绪队列"]
B --> C["调度器选择线程"]
C --> D["获得 CPU 执行"]
D --> E{"执行状态"}
E -->|"继续运行"| D
E -->|"时间片耗尽"| B
E -->|"等待资源"| F["阻塞队列"]
F --> G["资源就绪"]
G --> B
E -->|"执行完成"| H["终止状态"]
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
3. 同步机制(Synchronization)
多个线程并发访问共享资源时,可能产生数据竞争。
例如:
class Counter {
int count = 0;
void increment() {
count++;
}
}
count++ 并不一定是一个不可分割的原子操作。
其逻辑通常包含:
- 读取当前值。
- 执行加法。
- 写回新值。
如果两个线程同时执行,可能发生更新丢失。
例如:
初始值:count = 0
线程 A:读取 0
线程 B:读取 0
线程 A:计算 1
线程 B:计算 1
线程 A:写入 1
线程 B:写入 1
最终结果:1
预期结果是 2,实际结果却是 1。
这就是典型的竞态条件。
常见同步机制:
| 机制 | 作用 |
|---|---|
| Mutex(互斥锁) | 保证同一时刻只有一个线程进入临界区 |
| Semaphore(信号量) | 控制同时访问资源的任务数量 |
| Condition Variable(条件变量) | 等待某个条件成立 |
| Read-Write Lock(读写锁) | 区分读操作和写操作 |
| Atomic Operation(原子操作) | 保证特定操作不可分割 |
| Barrier(屏障) | 等待多个任务到达同步点 |
4. 原子性、可见性与有序性
并发编程中经常需要关注三个基本属性。
原子性(Atomicity)
一个操作要么完整执行,要么不发生部分可见的中间状态。
例如,使用原子整数执行递增操作,可以避免普通读改写过程中的丢失更新。
可见性(Visibility)
一个线程对共享变量的修改,能够按照内存模型规定的同步关系被其他线程观察到。
有序性(Ordering)
编译器、CPU 和运行时可能进行指令重排,只要不违反相应语言和硬件内存模型所允许的语义。
并发程序必须通过适当的同步机制建立必要的顺序约束。
例如 Java 的 volatile 可以提供特定的可见性和有序性保证,但不能将普通的 count++ 变成原子操作。
五、并发编程中的典型问题
1. 竞态条件(Race Condition)
竞态条件是指程序结果依赖多个任务执行时序,而这种时序可能发生变化。
例如:
if (account.balance >= amount) {
account.balance -= amount;
}
如果两个线程同时检查余额并执行扣款,就可能出现超额扣款。
问题不仅在于单个变量的读写,还在于检查与更新之间缺乏原子性。
解决方式:
- 使用互斥锁保护整个业务操作。
- 使用数据库事务。
- 使用原子状态转换。
- 采用消息队列串行处理。
- 使用不可变数据结构减少共享写入。
2. 死锁(Deadlock)
死锁是指多个任务互相等待对方持有的资源,导致所有相关任务无法继续执行。
经典场景:
- 线程 A 持有锁 1,等待锁 2。
- 线程 B 持有锁 2,等待锁 1。
flowchart TB
A["线程 A"] --> B["持有锁 1"]
B --> C["等待锁 2"]
D["线程 B"] --> E["持有锁 2"]
E --> F["等待锁 1"]
C --> G["死锁"]
F --> G
G --> H["两个线程均无法继续"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
style G fill:#FBE9E9,stroke:#D9AAAA,color:#334155
style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
死锁通常需要同时满足四个条件:
- 互斥:资源不能被多个任务同时独占使用。
- 持有并等待:任务持有资源的同时等待其他资源。
- 不可抢占:资源不能被强制从任务手中夺走。
- 循环等待:多个任务形成资源等待环。
常见预防措施:
- 统一锁获取顺序。
- 缩小锁的持有范围。
- 避免嵌套锁。
- 使用超时锁。
- 减少共享资源。
- 使用无锁或消息传递模型。
3. 活锁(Livelock)
活锁是指多个任务一直在执行状态调整,但始终无法完成实际工作。
例如:
两个线程发现资源冲突后,都主动释放资源并重试,结果不断重复相同操作。
与死锁不同:
- 死锁:任务无法继续执行。
- 活锁:任务持续执行,但没有有效进展。
可以通过随机退避、重试间隔和协调策略缓解活锁。
4. 饥饿(Starvation)
饥饿是指某个任务长期无法获得所需资源或执行机会。
常见原因:
- 高优先级任务持续占用 CPU。
- 锁被某些线程反复获取。
- 调度策略缺乏公平性。
- 资源分配不合理。
解决方式包括:
- 公平锁。
- 优先级调整。
- 公平调度。
- 限制资源占用时间。
- 引入超时与排队机制。
5. 并发问题对比
| 问题 | 核心表现 | 典型原因 |
|---|---|---|
| 竞态条件 | 结果依赖执行时序 | 共享状态缺乏正确同步 |
| 死锁 | 任务相互等待,无法推进 | 循环资源等待 |
| 活锁 | 持续活动但无法完成 | 不断冲突和重试 |
| 饥饿 | 部分任务长期得不到资源 | 调度或资源分配不公平 |
六、并行计算的核心机制
并行计算的目标是将计算任务拆分到多个处理单元上执行。
1. 数据并行(Data Parallelism)
数据并行是指将数据拆分成多个部分,对不同部分执行相同或相似的计算。
例如,对一个大型数组中的所有元素执行平方运算。
result = [x * x for x in data]
在并行计算中,可以将数据划分为多个分片:
flowchart TB
A["大型数据集合"] --> B["数据分片"]
B --> C["分片 1"]
B --> D["分片 2"]
B --> E["分片 3"]
B --> F["分片 4"]
C --> G["处理单元 1"]
D --> H["处理单元 2"]
E --> I["处理单元 3"]
F --> J["处理单元 4"]
G --> K["合并结果"]
H --> K
I --> K
J --> K
K --> L["最终结果"]
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:#E5F4EC,stroke:#A3CBB5,color:#334155
style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
style I fill:#FFF5DE,stroke:#E8D29A,color:#334155
style J fill:#FFF5DE,stroke:#E8D29A,color:#334155
style K fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style L fill:#E5F4EC,stroke:#A3CBB5,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
典型场景:
- 图像像素处理。
- 矩阵计算。
- 大规模数组运算。
- 机器学习张量计算。
- 科学计算。
2. 任务并行(Task Parallelism)
任务并行是指将不同计算任务分配给不同处理单元执行。
例如,一个视频处理系统可以同时执行:
- 视频解码。
- 音频解码。
- 图像滤镜。
- 音频增强。
- 数据编码。
不同任务可能执行不同的算法,输入和输出也可能不同。
3. 流水线并行(Pipeline Parallelism)
流水线并行将一个复杂任务拆分成多个阶段,不同阶段可以同时处理不同的数据。
例如视频处理:
flowchart LR
A["读取数据"] --> B["解码"]
B --> C["图像处理"]
C --> D["编码"]
D --> E["输出"]
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
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
当不同阶段处理不同数据块时,可以形成流水线重叠执行。
例如:
- 阶段 1 读取第 3 个数据块。
- 阶段 2 处理第 2 个数据块。
- 阶段 3 编码第 1 个数据块。
流水线并行的优势在于提高整体吞吐量,但不一定减少单个数据块从开始到结束的完整延迟。
4. 数据并行与任务并行对比
| 对比维度 | 数据并行 | 任务并行 |
|---|---|---|
| 拆分对象 | 数据集合 | 计算任务 |
| 执行内容 | 通常相同或相似 | 可以完全不同 |
| 数据关系 | 通常相对独立 | 可能存在任务依赖 |
| 典型场景 | 矩阵、图像、数组 | 多阶段处理、独立服务 |
| 主要挑战 | 数据划分与结果合并 | 任务调度与依赖协调 |
七、并发与并行的性能分析
并发和并行并不一定能够提升程序性能。
任务拆分、同步、通信和调度都会带来额外成本。
1. 吞吐量与延迟
吞吐量(Throughput)
单位时间内系统完成的任务数量。
例如:
- 每秒处理 1000 个 HTTP 请求。
- 每秒完成 500 次数据库事务。
- 每秒处理 100 万个数据元素。
延迟(Latency)
单个任务从开始到完成所需要的时间。
例如:
- 一个 HTTP 请求耗时 50ms。
- 一次数据库查询耗时 20ms。
- 一张图片处理耗时 200ms。
并发通常可以提高系统同时处理多个请求的能力,但不一定降低单个请求的延迟。
并行则可能缩短计算任务的执行时间,但如果同步和通信成本过高,也可能导致性能下降。
2. 阿姆达尔定律(Amdahl's Law)
阿姆达尔定律用于描述并行化对程序整体加速比的理论限制。
假设:
- P:程序中可以并行执行的比例。
- 1-P:必须串行执行的比例。
- N:并行处理单元数量。
理论加速比:
例如:
如果程序中:
- 80% 的代码可以并行。
- 20% 的代码必须串行。
- 使用 4 个处理单元。
那么:
即理论加速比为 2.5 倍。
即使处理单元数量趋近于无穷大:
当 P=0.8 时:
这意味着串行部分会限制程序的最大加速比。
实际系统还需要考虑通信、同步、调度和负载不均衡等额外开销,因此实际加速比通常低于理想模型。
3. 古斯塔夫森定律(Gustafson's Law)
阿姆达尔定律主要分析固定问题规模下增加处理单元的效果。
古斯塔夫森定律则从固定运行时间、扩大问题规模的角度分析并行计算。
其表达式:
其中:
- N:处理单元数量。
- \alpha:串行部分占总执行时间的比例。
它强调:随着计算资源增加,可以处理更大的问题,而不只是加速固定规模的任务。
4. 并行计算的性能瓶颈
常见瓶颈包括:
- 串行代码比例过高。
- 任务划分不均衡。
- 线程调度开销。
- 锁竞争。
- 进程间通信开销。
- 内存带宽限制。
- CPU 缓存失效。
- NUMA 远程内存访问。
- 数据同步成本。
5. 负载均衡(Load Balancing)
负载均衡是指合理分配任务,使不同处理单元的工作量尽可能均衡。
如果某个核心任务已经完成,而另一个核心仍然处理大量任务,系统整体完成时间仍然受最慢任务限制。
常见策略:
- 静态任务划分。
- 动态任务分配。
- 工作窃取(Work Stealing)。
- 分块处理。
- 任务队列。
工作窃取是许多并行运行时的重要调度策略:空闲工作线程可以从其他线程的任务队列中获取任务,以提高处理器利用率。
八、I/O 密集型与 CPU 密集型任务
任务类型会直接影响并发与并行方案的选择。
1. CPU 密集型任务
CPU 密集型任务主要消耗处理器计算资源。
例如:
- 图像处理。
- 视频编码。
- 数据压缩。
- 加密计算。
- 数值计算。
- 机器学习推理。
这类任务通常适合通过多进程、多线程或并行计算框架利用多个 CPU 核心。
如果任务能够拆分为相互独立的计算单元,并且同步成本较低,并行执行通常更有价值。
2. I/O 密集型任务
I/O 密集型任务主要等待外部资源。
例如:
- 网络请求。
- 数据库查询。
- 文件读写。
- RPC 调用。
- 消息队列消费。
在等待 I/O 的过程中,执行单元可能无法继续当前工作。
可以通过异步 I/O、事件循环或线程池,让其他任务在等待期间继续推进。
3. 两种任务的处理策略
| 对比维度 | CPU 密集型 | I/O 密集型 |
|---|---|---|
| 主要瓶颈 | CPU 计算能力 | 外部 I/O 等待 |
| 典型任务 | 图像处理、压缩 | 网络请求、数据库查询 |
| 常用方案 | 多核并行、进程池 | 异步 I/O、线程池 |
| 主要目标 | 提高计算吞吐量 | 提高资源利用率和并发能力 |
| 线程数量 | 通常围绕 CPU 核心数设计 | 可根据等待时间和资源限制调整 |
| 关键风险 | 计算负载不均、同步开销 | 连接耗尽、资源堆积、超时 |
这只是一般性建议。实际线程数量还受到任务粒度、运行时实现、内存、I/O 限制和系统调度策略影响。