返回专栏
· 21 分钟阅读

并发与并行


一、什么是并发与并行

并发(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++ 并不一定是一个不可分割的原子操作。

其逻辑通常包含:

  1. 读取当前值。
  2. 执行加法。
  3. 写回新值。

如果两个线程同时执行,可能发生更新丢失。

例如:

初始值: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

死锁通常需要同时满足四个条件:

  1. 互斥:资源不能被多个任务同时独占使用。
  2. 持有并等待:任务持有资源的同时等待其他资源。
  3. 不可抢占:资源不能被强制从任务手中夺走。
  4. 循环等待:多个任务形成资源等待环。

常见预防措施:

  • 统一锁获取顺序。
  • 缩小锁的持有范围。
  • 避免嵌套锁。
  • 使用超时锁。
  • 减少共享资源。
  • 使用无锁或消息传递模型。

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:并行处理单元数量。

理论加速比:

S(N)=\frac{1}{(1-P)+\frac{P}{N}}

例如:

如果程序中:

  • 80% 的代码可以并行。
  • 20% 的代码必须串行。
  • 使用 4 个处理单元。

那么:

S(4)=\frac{1}{0.2+\frac{0.8}{4}}
S(4)=\frac{1}{0.4}=2.5

即理论加速比为 2.5 倍。

即使处理单元数量趋近于无穷大:

S(\infty)=\frac{1}{1-P}

当 P=0.8 时:

S(\infty)=5

这意味着串行部分会限制程序的最大加速比。

实际系统还需要考虑通信、同步、调度和负载不均衡等额外开销,因此实际加速比通常低于理想模型。

3. 古斯塔夫森定律(Gustafson's Law)

阿姆达尔定律主要分析固定问题规模下增加处理单元的效果。

古斯塔夫森定律则从固定运行时间、扩大问题规模的角度分析并行计算。

其表达式:

S(N)=N-\alpha(N-1)

其中:

  • 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 限制和系统调度策略影响。

九、不同语言的并发与并行模型