返回专栏
· 21 分钟阅读

Actor 模型


一、什么是 Actor 模型?

Actor 模型(Actor Model)是一种用于描述并发计算的数学模型和编程范式。它将系统中的计算实体抽象为独立的 Actor(参与者),每个 Actor 都拥有自己的状态、行为和消息邮箱。

Actor 之间不直接访问彼此的内部状态,也不通过共享内存进行协作,而是通过发送消息完成通信。

一个 Actor 接收到消息后,可以执行以下操作:

  1. 创建新的 Actor。
  2. 向其他 Actor 发送消息。
  3. 更新自己的内部状态,以便处理后续消息。

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 消息顺序

消息顺序需要区分不同范围:

  1. 单个发送方到单个接收方。
  2. 多个发送方到同一个接收方。
  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 条消息。

邮箱积压会持续增加。

常见影响:

  • 内存占用增长。
  • 消息处理延迟增加。
  • 系统响应变慢。
  • 最终可能发生内存耗尽。

解决方式:

  1. 使用有界邮箱。
  2. 限制发送速率。
  3. 使用背压机制(Backpressure)。
  4. 拆分热点 Actor。
  5. 优化消息处理逻辑。
  6. 监控邮箱长度和消息等待时间。

需要注意,有界邮箱必须定义溢出策略,例如拒绝、丢弃、阻塞或转入持久化队列。

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