derive_aktor

一个生成 Rust actor 的宏

derive_aktor 导出 derive_actor 宏。这个宏可以接受一个结构的 impl 并为其生成一个 actor，其中 actor 具有与 impl 相当的、类型化的 API。

这使得编写类型化、名义化、异步 API 变得容易。

这与许多 actor 实现（如）形成对比，这些实现要么

a) 不强制消息的类型安全 b) 仅暴露一个用于与 actor 通信的 API，如 "send"，并强制你构造消息

示例

这里有一个简单的 "KeyValueStore" 示例。我们可以异步地与之交互，跨线程共享它，

pub struct KeyValueStore<U>
    where U: Hash + Eq + Send + 'static
{
    inner_store: HashMap<U, String>,
    self_actor: Option<KeyValueStoreActor<U>>,
}

impl<U: Hash + Eq + Send + 'static> KeyValueStore<U> {
    pub fn new() -> Self {
        Self {
            inner_store: HashMap::new(),
            self_actor: None,
        }
    }
}

// All methods in this block form our Actor's API
#[derive_actor]
impl<U: Hash + Eq + Send + 'static> KeyValueStore<U> {
    pub fn query(&self, key: U, f: Box<dyn Fn(Option<String>) + Send + 'static>) {
        println!("query");
        f(self.inner_store.get(&key).map(String::from))
    }

    pub fn set(&mut self, key: U, value: String) {
        println!("set");
        self.inner_store.insert(key, value);
    }
}


#[tokio::main]
async fn main() {

    let (kv_store, handle) = KeyValueStoreActor::new(KeyValueStore::new()).await;
    
    // We can use an async API that's typed and nominal
    kv_store.query("foo", Box::new(|value| println!("before {:?}", value))).await;
    kv_store.set("foo", "bar".to_owned()).await;
    kv_store.query("foo", Box::new(|value| println!("after {:?}", value))).await;

    // We must drop any references to kv_store before we await the handle, or it will leak!

    drop(kv_store);
    handle.await;
}

示例 - Actor 通信

struct Logger {}

#[derive_actor]
impl Logger {
    pub fn log(&self, data: String) {info!("{}", data)}
}



struct Simple{}

#[derive_actor]
impl Simple {
    pub fn takes_actor(&self, log_actor: LoggerActor) {
        info!("Logging up here");
        log_actor.log("and logging over here".to_owned()).await;
    }
}

#[tokio::main]
async fn main() {

    let (logger, l_handle) = LoggerActor::new(Logger{}).await;
    let (simple, s_handle) = SimpleActor::new(Simple{}).await;

    simple.takes_actor(logger.clone());
    
    drop(logger);
    drop(simple);

    l_handle.await;
    s_handle.await;  // you could also join!(l_handle, s_handle);
}

什么是 Actor？

Actor 是一种并发原语，类似于线程，您通过消息传递与之通信。

实现

术语

• Actor - 这是生成的 Actor 结构体
• ActorImpl - 这是您编写的具有 impl 的结构体

Actor

Actor 实际上只是一个围绕 mpsc Sender 的包装器。Actor 提供了一个基于您附加 derive_actor 宏的 impl 块的 API。

#[derive_actor]
impl MyStruct {
    pub fn my_method(&mut self) {}
}

struct MyStructActor {
    // ..
}

impl MyStructActor {
    // ...
    async pub fn my_method(&self) {
      // package the message, place it on the internal queue, pass it along
    }
}