How to Use the Actor Model in Rust

Core
2026-04-17T16:43:47+00:00
The Actor Model in Rust is best implemented using the `tokio` ecosystem, specifically the `tokio::sync::mpsc` channel for message passing and `tokio::spawn` for concurrent actor lifecycles, rather than relying on a single heavy framework.

The Actor Model in Rust is best implemented using the tokio ecosystem, specifically the tokio::sync::mpsc channel for message passing and tokio::spawn for concurrent actor lifecycles, rather than relying on a single heavy framework. You define an actor as a struct that owns a receiver channel, runs an infinite loop to process messages, and spawns this loop as a lightweight task within a Tokio runtime.

Here is a practical example of a simple counter actor that increments a value based on incoming messages:

use tokio::sync::mpsc;
use tokio::task::JoinHandle;

// Define the message type
#[derive(Debug)]
enum CounterMessage {
    Increment,
    Get(Option<mpsc::Sender<i32>>),
}

// The actor struct
struct Counter {
    value: i32,
    rx: mpsc::Receiver<CounterMessage>,
}

impl Counter {
    fn new() -> (Self, mpsc::Sender<CounterMessage>) {
        let (tx, rx) = mpsc::channel(100);
        let counter = Counter { value: 0, rx };
        (counter, tx)
    }

    async fn run(mut self) {
        while let Some(msg) = self.rx.recv().await {
            match msg {
                CounterMessage::Increment => {
                    self.value += 1;
                }
                CounterMessage::Get(reply_tx) => {
                    if let Some(tx) = reply_tx {
                        let _ = tx.send(self.value).await;
                    }
                }
            }
        }
    }
}

#[tokio::main]
async fn main() {
    let (counter, tx) = Counter::new();
    
    // Spawn the actor as a background task
    let _handle: JoinHandle<()> = tokio::spawn(counter.run());

    // Send messages to the actor
    tx.send(CounterMessage::Increment).await.unwrap();
    tx.send(CounterMessage::Increment).await.unwrap();

    // Request the current value
    let (reply_tx, reply_rx) = mpsc::channel(1);
    tx.send(CounterMessage::Get(Some(reply_tx))).await.unwrap();

    if let Some(value) = reply_rx.recv().await {
        println!("Current count: {}", value); // Prints: 2
    }
}

For larger applications, you might prefer the actix crate, which provides a more robust actor system with built-in supervision, lifecycle management, and address types. However, tokio channels are often sufficient for most use cases and keep dependencies minimal.

To use actix, you would define a Handler trait for your messages:

use actix::prelude::*;

#[derive(Message, Debug)]
#[rtype(result = "()")]
struct Increment;

struct Counter {
    value: i32,
}

impl Actor for Counter {
    type Context = Context<Self>;

    fn started(&mut self, _ctx: &mut Self::Context) {
        println!("Actor started");
    }
}

impl Handler<Increment> for Counter {
    type Result = ();

    fn handle(&mut self, _msg: Increment, _ctx: &mut Self::Context) {
        self.value += 1;
    }
}

#[actix::main]
async fn main() {
    let addr = Counter { value: 0 }.start();
    addr.send(Increment).await.unwrap();
    println!("Actor processed increment");
}

Key considerations when implementing actors in Rust include ensuring message types are Send + Sync if crossing threads, managing backpressure via bounded channels to prevent memory exhaustion, and handling errors gracefully within the actor loop to avoid dropping the entire task. Always prefer explicit message passing over shared mutable state to maintain the isolation guarantees of the Actor Model.