Actor

El actor es la primitiva principal del modelo. Son livianos, se pueden crear miles (en lugar de threads). Encapsulan comportamiento y estado. El actor supervisor puede crear otros actores hijo.

• Compuesto por:
  • Dirección: adonde enviarle mensajes.
  • Casilla de correo (mailbox): un FIFO de los últimos mensajes recibidos.
• Son aislados de otros actores: no comparten memoria.
• El estado privado solo puede cambiarse a partir de procesar mensajes.
• Pueden manejar un mensaje por vez.
• Los actores se comunican entre ellos solamente usando mensajes.
• Los mensajes son procesados por los actores de forma asincrónica.
• Los mensajes son estructuras simples inmutables.

use std::time::Duration;
use actix::prelude::*;

struct Producer {
    interval: Duration,
    consumer: Addr<Consumer>,
}

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

    fn started(&mut self, ctx: &mut Self::Context) {
        ctx.run_interval(self.interval, |act, _ctx| {
            let num = rand::random::<u32>();
            act.consumer.do_send(AddNumber(num));
        });
    }
}

struct AddNumber(u32);

impl Message for AddNumber {
    type Result = ();
}

struct GetSum;

impl Message for GetSum {
    type Result = u32;
}

struct Consumer {
    sum: u32,
}

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

impl Handler<AddNumber> for Consumer {
    type Result = ();

    fn handle(&mut self, msg: AddNumber, _ctx: &mut Self::Context) -> Self::Result {
        self.sum += msg.0;
    }
}

impl Handler<GetSum> for Consumer {
    type Result = u32;

    fn handle(&mut self, _msg: GetSum, _ctx: &mut Self::Context) -> Self::Result {
        self.sum
    }
}

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

    let consumer = Consumer { sum: 0 }.start();
    let _producer = Producer {
        interval: Duration::from_secs(1),
        consumer,
    }
    .start();

    system.run().unwrap();
}