返回专栏
· 18 分钟阅读

不同语言的并发模型


一、什么是并发模型?

并发模型(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. 并发模型的核心组成

一个完整的并发模型通常涉及以下几个部分:

组成部分 作用
执行单元 表示可以独立推进的任务,如线程、协程
调度器 决定任务何时获得执行机会
同步机制 协调任务之间的执行顺序
通信机制 在任务之间传递数据
状态管理 管理任务共享或独立的数据
生命周期管理 处理启动、等待、取消和结束
异常传播 定义任务失败如何影响其他任务

不同语言的并发模型,主要区别在于这些组成部分如何实现,以及语言和运行时为开发者提供了什么抽象。

二、并发模型的主要类型

从任务组织方式和通信机制来看,常见并发模型包括:

  1. 基于线程的并发模型。
  2. 基于事件循环的并发模型。
  3. 基于协程的并发模型。
  4. 基于 Actor 的并发模型。
  5. 基于消息传递的并发模型。
  6. 基于数据并行的并发模型。

这些模型并不完全互斥。

例如,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