Actor并发系统说明与使用

简介

Actor模型是一种并行计算模型，提供了一种用于构建并发、分布式系统的抽象方法

在Actor模型中，计算被表示为独立的、轻量级的计算单元，称为Actor，可以发送和接收消息并进行本地计算

作为一种通用的消息传递编程模型，被广泛用于构建大规模可伸缩分布式系统

核心思想是独立维护隔离状态，并基于消息传递实现异步通信

Actor模型组成

• 存储：每个 Actor 持有一个邮箱（mailbox），本质上是一个队列，用于存储消息
• 通信：每个 Actor 可以发送消息至任何 Actor，使用异步消息传递，不保证消息到达目标 Actor 时的顺序
• 计算： Actor 可以通过处理消息来更新内部状态，对于外部而言，Actor 的状态是隔离的isolated state

优势

• 每个 Actor 独立运行，因此程序自然是并行的
• 每个Actor都完全独立于其他实例，不存在共享内存和竞争条件的问题，可以避免并发编程中的一些难点
• 通过消息传递进行通信，每个Actor都有一个邮箱来接收消息，每次只处理一个消息，以确保状态的一致性和线程安全
• 消息传递是异步的，发送方不需要等待接收方的响应，从而避免了锁和同步的开销
• 提供高度的并发性和可扩展性，能够有效地解决多核CPU和分布式系统中的并发编程问题
• 提供良好的容错性和可恢复性，因为每个Actor都有自己的状态和行为，可以更容易地实现系统的容错和恢复

Actor 基于线程的任务调度

为每一个 Actor 分配一个独立的执行过程（线程），独占该线程，可以是操作系统线程，协程或者虚拟机线程

如果当前 Actor 的邮箱为空，Actor 会阻塞当前线程，等待接收新的消息

由于线程数量受到系统的限制，因此 Actor 的数量也会受到限制

Actor基于事件驱动的任务调度

只有在事件触发（即接收消息）时，才为 Actor 的任务分配线程并执行，当事件处理完毕，即退出线程

该方式可以使用很少的线程来执行大量 Actor 产生的任务，也是现在大部分Actor模型所采用的调度方式

这种实现与 run loop、event loop 机制非常相似

rust中的Actor模型实现-actix

Actix 建立在 Actor 模型的基础上，允许将应用程序编写为一组独立执行但协作的Actor，这些Actor通过消息进行通信

Actor 是封装状态和行为的对象，并在actix 库提供的Actor系统中运行

Actor 在特定的执行上下文 Context<A> 中运行， 上下文对象仅在执行期间可用， 每个 Actor 都有一个单独的执行上下文，执行上下文还控制 Actor 的生命周期。 Actor 仅通过交换消息进行通信

任何 Rust 类型都可以是 Actor，只需要实现 Actor Trait 即可

为了能够处理特定消息，参与者必须为此消息提供 Handler<M> 实现

基本使用

修改Cargo.toml

[dependencies]
actix = "0.11.0"
actix-rt = "2.2"

修改main.rs

use actix::prelude::*;

/// 定义消息的类型，rtype指定返回类型
#[derive(Message)]
#[rtype(result = "Result<bool, std::io::Error>")]
struct Ping;

// 定义Actor
struct MyActor;

// 集成Actor Trait
impl Actor for MyActor {
    type Context = Context<Self>;

    fn started(&mut self, ctx: &mut Context<Self>) {
        println!("Actor is alive");
    }

    fn stopped(&mut self, ctx: &mut Context<Self>) {
        println!("Actor is stopped");
    }
}

/// Define handler for `Ping` message
impl Handler<Ping> for MyActor {
    type Result = Result<bool, std::io::Error>;

    fn handle(&mut self, msg: Ping, ctx: &mut Context<Self>) -> Self::Result {
        println!("Ping received");

        Ok(true)
    }
}

#[actix_rt::main]
async fn main() {
    // Start MyActor in current thread
    let addr = MyActor.start();

    // Send Ping message.
    // send() message returns Future object, that resolves to message result
    let result = addr.send(Ping).await;

    match result {
        Ok(res) => println!("Got result: {}", res.unwrap()),
        Err(err) => println!("Got error: {}", err),
    }
}

运行结果

Actor is alive
Ping received
Got result: true

阅读参考

浅谈 Actor 模型

懒人专用高并发：Actor模型

Actix Actor官方文档