一、什么是 Actor 模型?
Actor 模型(Actor Model)是一种用于描述并发计算的数学模型和编程范式。它将系统中的计算实体抽象为独立的 Actor(参与者),每个 Actor 都拥有自己的状态、行为和消息邮箱。
Actor 之间不直接访问彼此的内部状态,也不通过共享内存进行协作,而是通过发送消息完成通信。
一个 Actor 接收到消息后,可以执行以下操作:
- 创建新的 Actor。
- 向其他 Actor 发送消息。
- 更新自己的内部状态,以便处理后续消息。
Actor 模型的核心思想是:
通过消息传递代替共享内存,通过独立状态代替共享可变数据,通过异步协作实现并发。
1.1 Actor 的基本组成
一个 Actor 通常包含三个核心部分:
| 组成 | 说明 |
|---|---|
| State(状态) | Actor 私有的数据,只能由自身行为访问和修改 |
| Behavior(行为) | 定义 Actor 如何处理接收到的消息 |
| Mailbox(邮箱) | 存放发送给 Actor、等待处理的消息队列 |
例如,一个银行账户 Actor 可以维护账户余额,并处理存款、取款和余额查询消息。
AccountActor
├── State
│ └── balance = 1000
├── Behavior
│ ├── Deposit(amount)
│ ├── Withdraw(amount)
│ └── GetBalance()
└── Mailbox
├── Deposit(200)
├── Withdraw(100)
└── GetBalance()
其他 Actor 不应该直接修改 balance,而是向账户 Actor 发送消息,由账户 Actor 自己处理状态变化。
1.2 Actor 的基本通信方式
Actor 之间通过消息传递进行协作。
flowchart LR
A["Actor A"] -->|"发送消息"| B["Actor B 的 Mailbox"]
B --> C["Actor B 处理消息"]
C --> D["更新 Actor B 的状态"]
D -->|"可选:发送响应"| 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:#FFF5DE,stroke:#E8D29A,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
需要注意,发送消息通常只表示消息被提交或发送,不代表目标 Actor 已经处理完成。
Actor 模型中的消息通信通常具有异步特征,发送方不必等待接收方完成处理。
二、Actor 模型的核心机制
2.1 消息传递(Message Passing)
消息传递是 Actor 模型最重要的通信机制。
Actor 之间不直接调用对方的内部方法,而是发送消息,接收方根据自身行为决定如何处理。
例如:
OrderActor
|
| CreateOrder(order)
v
InventoryActor
|
| ReserveStock(productId, quantity)
v
PaymentActor
|
| Charge(orderId, amount)
v
NotificationActor
上面的结构表达了不同 Actor 之间的协作关系。
实际系统中,消息可以包含:
- 操作类型。
- 业务参数。
- 请求标识。
- 关联 ID。
- 超时信息。
- 回复目标或响应地址。
消息最好采用不可变数据结构,避免发送方在消息发送后继续修改消息内容,从而引入状态竞争。
例如:
public record DepositMessage(long amount) {}
public record WithdrawMessage(long amount) {}
public record BalanceQuery(String requestId) {}
使用不可变消息,可以降低消息跨线程、跨进程传递时的数据一致性风险。
2.2 邮箱(Mailbox)
每个 Actor 通常拥有自己的邮箱。
邮箱负责接收消息,并按照运行时定义的调度策略,将消息交给 Actor 处理。
典型邮箱处理过程:
flowchart TB
A["发送方提交消息"] --> B["消息进入目标邮箱"]
B --> C["邮箱等待调度"]
C --> D["Actor 被调度执行"]
D --> E["取出一条消息"]
E --> F["执行对应行为"]
F --> G["处理完成"]
G --> H{"邮箱还有消息?"}
H -->|"是"| E
H -->|"否"| I["等待下一次调度"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
style I fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
邮箱不仅是一个普通队列,还可能包含:
- 消息排序策略。
- 优先级策略。
- 容量限制。
- 消息过滤。
- 调度和执行策略。
- 溢出处理策略。
不同 Actor 框架的邮箱实现并不完全相同。
例如,有的框架使用 FIFO 邮箱,有的支持优先级邮箱,也有的允许自定义邮箱实现。
需要注意:邮箱的 FIFO 顺序不等于所有发送方之间存在全局消息顺序。
如果多个发送方并发发送消息,消息到达邮箱的先后顺序可能受到调度和网络传输影响。
2.3 行为(Behavior)
Behavior 定义 Actor 收到不同消息时应该执行什么操作。
例如账户 Actor:
public class AccountActor {
private long balance = 1000;
public void onMessage(Object message) {
if (message instanceof DepositMessage m) {
balance += m.amount();
} else if (message instanceof WithdrawMessage m) {
if (balance >= m.amount()) {
balance -= m.amount();
}
} else if (message instanceof BalanceQuery) {
System.out.println("Balance: " + balance);
}
}
}
这里的示例展示了行为逻辑,但它本身还不是一个完整的 Actor 框架实现。
真正的 Actor 运行时还需要负责:
- 邮箱管理。
- 消息调度。
- 并发执行。
- Actor 生命周期。
- 异常隔离。
- 消息投递和运行时管理。
Actor 的状态只能由它自己的消息处理逻辑修改,可以避免多个执行线程直接竞争同一份内部状态。
2.4 状态隔离(State Isolation)
传统共享内存并发模型中,多个线程可能同时访问同一份数据。
例如:
class Counter {
int count = 0;
void increment() {
count++;
}
}
如果多个线程同时执行 increment(),就可能发生竞态条件。
Actor 模型通常将计数器封装为独立 Actor:
CounterActor
├── State
│ └── count = 0
└── Behavior
└── Increment
└── count = count + 1
其他 Actor 只能发送 Increment 消息,不能直接修改 count。
在单个 Actor 的消息处理逻辑不会并发执行的前提下,状态更新可以按消息处理顺序进行。
不过,状态隔离并不意味着整个系统不存在并发问题。多个 Actor 之间仍然可能出现消息顺序、业务竞争、超时和分布式一致性问题。
三、Actor 的执行模型
3.1 单个 Actor 通常串行处理消息
许多 Actor 实现采用单线程消息处理语义:同一个 Actor 在同一时刻只处理一条消息。
假设邮箱中存在三条消息:
Message A
Message B
Message C
处理过程通常是:
flowchart TB
A["Mailbox"] --> B["Message A"]
B --> C["执行 A"]
C --> D["A 处理完成"]
D --> E["Message B"]
E --> F["执行 B"]
F --> G["B 处理完成"]
G --> H["Message C"]
H --> I["执行 C"]
I --> J["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:#E8EDF2,stroke:#B8C3CE,color:#334155
style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style I fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style J fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
这意味着:
- 同一个 Actor 的状态更新通常不需要额外加锁。
- 同一个 Actor 的消息处理逻辑具有串行执行语义。
- 不同 Actor 可以并发处理消息。
- Actor 的数量可以远大于实际工作线程的数量。
这里的串行是针对同一个 Actor 的消息处理,不代表整个系统只能串行执行。
3.2 不同 Actor 可以并发执行
假设系统存在三个 Actor:
- OrderActor:处理订单。
- InventoryActor:处理库存。
- PaymentActor:处理支付。
它们可以由不同工作线程并发调度。
flowchart TB
A["Actor Runtime"] --> B["Scheduler"]
B --> C["Worker 1"]
B --> D["Worker 2"]
B --> E["Worker 3"]
C --> F["OrderActor"]
D --> G["InventoryActor"]
E --> H["PaymentActor"]
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:#FFF5DE,stroke:#E8D29A,color:#334155
style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
实际 Actor 运行时通常会复用线程池或调度器,而不是为每个 Actor 创建一个操作系统线程。
因此,Actor 数量可以非常庞大,而底层工作线程数量由运行时控制。
3.3 Actor 不等于线程
这是理解 Actor 模型时非常重要的一点。
| 对比维度 | Actor | 线程 |
|---|---|---|
| 抽象层次 | 并发计算实体 | 操作系统或运行时执行单元 |
| 状态 | 通常拥有私有状态 | 可访问共享内存 |
| 通信 | 主要通过消息传递 | 可通过共享内存、消息等方式 |
| 调度 | 通常由 Actor Runtime 管理 | 由操作系统或运行时调度 |
| 数量 | 可以非常多 | 通常受到资源限制 |
| 生命周期 | 由 Actor 系统管理 | 由线程运行时管理 |
一个 Actor 不一定对应一个线程。
在许多实现中,多个 Actor 可以共享工作线程池,调度器负责将不同 Actor 的消息处理任务分配给可用线程。
3.4 Actor 的调度机制
Actor Runtime 通常包含调度器(Scheduler),负责管理可执行的 Actor 或消息处理任务。
典型调度过程:
flowchart TB
A["消息进入邮箱"] --> B["Actor 标记为可执行"]
B --> C["Scheduler 获取执行任务"]
C --> D["分配给 Worker"]
D --> E["执行消息处理逻辑"]
E --> F{"邮箱是否还有消息?"}
F -->|"是"| G["重新进入调度队列"]
F -->|"否"| H["Actor 等待新消息"]
G --> 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:#FFF5DE,stroke:#E8D29A,color:#334155
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
调度器需要考虑:
- 工作线程的负载均衡。
- 消息处理的公平性。
- Actor 的执行状态。
- 邮箱积压情况。
- 长时间运行的消息处理任务。
如果某个 Actor 的消息处理逻辑长期阻塞,可能占用工作线程,影响其他 Actor 的调度。
因此,Actor 模型并不意味着可以忽略阻塞操作。
四、Actor 模型与共享内存并发模型
Actor 模型与传统线程共享内存模型,在状态管理和通信方式上存在明显差异。
4.1 共享内存模型
共享内存模型允许多个线程访问同一份数据。
例如:
class SharedCounter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
这里通过 synchronized 保证临界区的互斥访问。
但随着共享数据和线程数量增加,系统可能出现:
- 锁竞争。
- 死锁。
- 锁粒度过大。
- 状态耦合。
- 并发调试困难。
4.2 Actor 模型
Actor 模型将共享状态封装在独立实体中。
多个发送方
|
v
CounterActor
|
+-- Mailbox
|
+-- State: count
|
+-- Behavior: Increment / GetCount
发送方只能通过消息请求 Actor 修改或查询状态。
在满足单 Actor 消息串行处理语义的情况下,不需要为该 Actor 的私有状态更新增加传统互斥锁。
4.3 两种模型对比
| 对比维度 | 共享内存模型 | Actor 模型 |
|---|---|---|
| 状态管理 | 多线程可能共享状态 | Actor 通常拥有私有状态 |
| 通信方式 | 共享变量、锁、条件变量等 | 消息传递 |
| 同步机制 | 锁、原子操作、屏障等 | 邮箱和消息调度 |
| 并发控制 | 开发者管理共享状态 | 运行时提供部分隔离保障 |
| 数据竞争 | 容易因共享访问产生 | 私有状态可降低此类风险 |
| 典型问题 | 死锁、竞态、锁竞争 | 消息积压、顺序、超时、失败 |
| 适用场景 | 细粒度共享数据计算 | 状态隔离、异步协作和分布式系统 |
两种模型并不是完全互斥的。
实际系统可以同时使用 Actor、线程池、原子操作、数据库事务和共享内存。
五、Actor 模型中的消息语义
消息传递虽然降低了共享状态带来的复杂性,但消息本身也会引入新的问题。
5.1 消息发送与消息处理不是一回事
假设 A 向 B 发送消息:
A 发送 Request
|
v
B 的 Mailbox 接收 Request
|
v
B 等待调度
|
v
B 处理 Request
|
v
B 返回 Response
消息发送成功不代表业务处理成功。
必须区分:
| 阶段 | 含义 |
|---|---|
| 发送 | 发送方提交消息 |
| 接收 | 消息进入目标邮箱或传输层 |
| 处理 | Actor 开始执行消息逻辑 |
| 完成 | 消息对应的业务操作执行结束 |
| 持久化 | 业务结果被可靠保存 |
不同 Actor 框架对发送成功的定义可能不同。
例如,消息可能只是进入本地内存邮箱,并没有持久化,也不代表目标 Actor 一定会完成处理。
5.2 消息投递语义
分布式 Actor 系统需要考虑消息可能丢失、重复或延迟的问题。
常见的消息投递语义包括:
| 语义 | 含义 | 主要问题 |
|---|---|---|
| At-most-once | 最多投递一次 | 可能丢失 |
| At-least-once | 至少投递一次 | 可能重复 |
| Exactly-once | 业务效果只发生一次 | 需要额外机制保证 |
需要特别注意:
Exactly-once 通常指业务效果层面的恰好一次,而不是消息在网络中只传输一次。
例如,支付服务可能因为网络超时重试同一笔支付请求。
如果没有幂等处理,可能产生重复扣款。
常见解决方式包括:
- 为请求分配唯一业务 ID。
- 保存已经处理过的请求 ID。
- 使用幂等键(Idempotency Key)。
- 将业务状态和去重记录放在同一事务中。
- 对消息消费进度进行可靠管理。
5.3 消息顺序
消息顺序需要区分不同范围:
- 单个发送方到单个接收方。
- 多个发送方到同一个接收方。
- 多个 Actor 之间的全局顺序。
同一个发送方按照顺序发送消息,并不意味着所有 Actor 框架都能保证接收方严格按照该顺序处理。
当多个发送方同时向同一个 Actor 发送消息时,系统通常不存在天然的全局顺序。
如果业务依赖顺序,应显式设计:
- 消息序列号。
- 版本号。
- 单一消息生产者。
- 有序消息通道。
- 状态机校验。
- 基于业务 ID 的顺序控制。
5.4 请求与响应(Request-Response)
Actor 模型虽然以异步消息为基础,但并不意味着不能进行请求响应式交互。
例如,发送方向目标 Actor 发送查询消息,并通过 Future、Promise 或响应 Actor 接收结果。
ClientActor
|
| GetBalance(requestId)
v
AccountActor
|
| BalanceResult(requestId, balance)
v
ClientActor
在实际框架中,可能使用以下机制:
- Ask 模式:发送请求并等待响应。
- Tell 模式:只发送消息,不等待结果。
- Future / Promise:异步获取结果。
- ReplyTo:在消息中携带响应目标。
Ask 模式通常需要设置超时。
如果目标 Actor 没有响应,调用方不能无限等待。
六、Actor 的生命周期与监督机制
Actor 不只是一个处理消息的对象,还具有完整的生命周期。
6.1 Actor 生命周期
常见的生命周期状态包括:
- Created:创建。
- Started:启动。
- Running:运行。
- Stopped:停止。
- Failed:异常失败。
典型生命周期:
flowchart TB
A["创建 Actor"] --> B["初始化"]
B --> C["启动运行"]
C --> D["处理消息"]
D --> E{"是否发生异常?"}
E -->|"否"| D
E -->|"是"| F["进入失败处理"]
F --> G{"监督策略"}
G -->|"重启"| H["重新初始化"]
H --> C
G -->|"停止"| I["停止 Actor"]
G -->|"升级处理"| J["交由上级监督"]
J --> K["上级 Actor 处理"]
C --> L["正常停止"]
L --> M["释放资源"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
style F fill:#FBE9E9,stroke:#D9AAAA,color:#334155
style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style I fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style J fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style K fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style L fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style M fill:#E5F4EC,stroke:#A3CBB5,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
具体生命周期状态和回调方法由 Actor 框架定义,不同框架并不完全一致。
6.2 监督机制(Supervision)
Actor 模型常见的设计是让 Actor 之间形成父子关系。
父 Actor 可以监督子 Actor 的运行状态。
当子 Actor 出现异常时,父 Actor 根据监督策略决定如何处理。
常见策略包括:
| 策略 | 说明 |
|---|---|
| Resume | 保留 Actor 当前状态,尝试继续运行 |
| Restart | 重新启动 Actor |
| Stop | 停止 Actor |
| Escalate | 将异常交给上级监督者 |
例如:
RootActor
├── OrderActor
├── PaymentActor
└── InventoryActor
如果 PaymentActor 发生异常,可以由 RootActor 或其直接监督者决定是否重启、停止或向上升级。
6.3 重启不等于恢复状态
这是 Actor 监督机制中非常容易被忽略的问题。
重启 Actor 通常意味着重新初始化其运行实例,但不一定能够恢复之前的业务状态。
如果 Actor 的状态只保存在内存中,进程崩溃后可能全部丢失。
因此,重要状态通常需要结合:
- 数据库持久化。
- 事件溯源(Event Sourcing)。
- 快照(Snapshot)。
- 消息日志。
- 状态恢复机制。
监督机制主要解决运行时异常隔离和恢复问题,并不自动提供业务数据持久化。
七、Actor 模型中的常见问题与解决方案
7.1 消息积压(Mailbox Backlog)
如果消息进入邮箱的速度超过 Actor 的处理速度,邮箱中的消息就会不断积累。
例如:
- 每秒进入 10,000 条消息。
- Actor 每秒只能处理 5,000 条消息。
邮箱积压会持续增加。
常见影响:
- 内存占用增长。
- 消息处理延迟增加。
- 系统响应变慢。
- 最终可能发生内存耗尽。
解决方式:
- 使用有界邮箱。
- 限制发送速率。
- 使用背压机制(Backpressure)。
- 拆分热点 Actor。
- 优化消息处理逻辑。
- 监控邮箱长度和消息等待时间。
需要注意,有界邮箱必须定义溢出策略,例如拒绝、丢弃、阻塞或转入持久化队列。
7.2 热点 Actor(Hot Actor)
如果大量请求都发送给同一个 Actor,它可能成为系统瓶颈。
例如:
UserActor A ─┐
UserActor B ─┼──> GlobalCounterActor
UserActor C ─┤
UserActor D ─┘
所有请求集中到一个 Actor,导致消息处理串行化。
解决方式:
- 将一个 Actor 拆分为多个分片。
- 按用户 ID、订单 ID 等业务键路由。
- 使用分布式计数器。
- 使用多个局部状态聚合结果。
- 将读写职责分离。
例如,可以将全局计数器拆成多个局部计数器:
CounterGroup
├── CounterActor 1
├── CounterActor 2
├── CounterActor 3
└── CounterActor 4