Module actix::sync

Sync actors support

Sync actors could be used for cpu bound load. Only one sync actor runs within arbiter's thread. Sync actor process one message at a time. Sync arbiter can start multiple threads with separate instance of actor in each. Note on actor stopping lifecycle event, sync actor can not prevent stopping by returning false from stopping method. Multi consumer queue is used as a communication channel queue. To be able to start sync actor via SyncArbiter Actor has to use SyncContext as an execution context.

Example

use actix::prelude::*;

struct Fibonacci(pub u32);

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

struct SyncActor;

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

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

    fn handle(&mut self, msg: Fibonacci, _: &mut Self::Context) -> Self::Result {
        if msg.0 == 0 {
            Err(())
        } else if msg.0 == 1 {
            Ok(1)
        } else {
            let mut i = 0;
            let mut 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() {
    System::run(|| {
        // start sync arbiter with 2 threads
        let addr = SyncArbiter::start(2, || SyncActor);

        // send 5 messages
        for n in 5..10 {
            addr.do_send(Fibonacci(n));
        }

    });
}

Structs

SyncArbiter	Sync arbiter
SyncContext	Sync actor execution context