Actix 系统，多个仲裁器 = 多少个线程

Question

问题 - 如果您有一个系统但有多个仲裁器在运行，它仍然是一个单线程事件循环吗？

阅读 Actix 书籍 - https://actix.rs/book/actix/sec-6-sync-arbiter.html

当您正常运行 Actor 时，系统的仲裁线程上会运行多个 Actor，使用其事件循环

还有来自https://actix.rs/book/actix/sec-5-arbiter.html

虽然它只使用一个线程，但它使用了非常有效的事件循环模式，该模式非常适用于异步事件。要处理同步的、受 CPU 限制的任务，最好避免阻塞事件循环，而是将计算卸载到其他线程。对于这个用例，请阅读下一部分并考虑使用 SyncArbiter。

问题重复 - 如果您有一个系统，但其中有多个仲裁器在运行，它仍然是一个单线程事件循环吗？

例子

let sys = System::new();
sys.block_on( async move {
    let arbiter1 = Arbiter::new(); // one arbiter here
    arbiter1.spawn( SOME ACTOR);
    let arbiter2 = Arbiter::new(); // another arbiter here
    arbiter2.spanw( SOME OTHER ACTOR);
});

sys.run().unwrap();

这是否在单个线程中运行？

当我使用 log4rs 记录它时，我看到以下内容

[actix-rt|system:0|arbiter:0]
[actix-rt|system:0|arbiter:1]

鉴于它是 system:0 - 这是否意味着它只是使用不同的仲裁器是同一个线程？

我需要运行多个System::new 才能在actix 中实现正确的多线程吗？

Answer 1

引用完全相同的book：

要以并发方式使用 Actix，您可以使用 Arbiter::new、ArbiterBuilder 或 Arbiter::start 启动多个 Arbiter。

也在Arbiter::new()的文档中

产生一个新的仲裁线程并启动它的事件循环。

所以你绝对可以有一个多线程的事件循环。

下面是一个例子。在执行期间，使用进程监控软件查看线程数（例如 MacOS 的 Activity Monitor、Windows 的 Process Explorer、Linux 的 htop）。

extern crate actix;
use actix::prelude::*;

struct Fibonacci(pub u32);


struct SomeActor;

impl Actor for SomeActor {
    type Context = Context<Self>;
}

impl Message for Fibonacci{
    type Result = Result<u64, ()>;
}

impl Handler<Fibonacci> for SomeActor {
    type Result = Result<u64, ()>;

    fn handle(&mut self, msg: Fibonacci, context: &mut Self::Context) -> Self::Result {
        println!("working on fib({})", msg.0);
    let mut sum=0;
    if msg.0 == 0 {
        Err(())
    } else if msg.0 == 1 {
        Ok(1)
    } else {

        for j in 1..1000000 {
            let mut i = 0;
            sum = 0;
            let mut last = 0;
            let mut curr = 1;
            while i < msg.0 - 1 {
                sum = last + curr;
                last = curr;
                curr = sum;
                i += 1;
            }
        }
        Ok(sum)
    }
}
}

fn main() {
let sys = System::new();

let a1 = Arbiter::new();
let a2 = Arbiter::new();
let a3 = Arbiter::new();

let execution1 = async {
    println!("exec 1 created");
    let sa = SomeActor {}.start();
    for n in 2..80 {
        sa.do_send(Fibonacci(n));
    }
};

let execution2 = async {
    println!("exec 2 created");
    let sa = SomeActor {}.start();
    for n in 2..80 {
        sa.do_send(Fibonacci(n));
    }
};

let execution3 = async {
    println!("exec 3 created");
    let sa = SomeActor {}.start();
    for n in 2..80 {
        sa.do_send(Fibonacci(n));
    }
};


a1.spawn(execution1);
a2.spawn(execution2);
a3.spawn(execution3);

sys.run();
}