async-observable

示例

简单分叉

use async_observable::Observable;

#[async_std::main]
async fn main() {
    let (mut a, mut b) = Observable::new(0).split();

    a.publish(1);

    assert_eq!(b.wait().await, 1);
}

通知任务

use async_std::task::{sleep, spawn};
use async_observable::Observable;

#[async_std::main]
async fn main() {
    let (mut main, mut task) = Observable::new(0).split();

    let task = spawn(async move {
        loop {
            let update = task.next().await;
            println!("task received update {}", update);

            if update >= 3 {
                break;
            }
        }
    });

    main.publish(1);
    sleep(std::time::Duration::from_millis(100)).await;
    main.publish(2);
    sleep(std::time::Duration::from_millis(100)).await;
    main.publish(3);

    task.await;
}

执行控制

您可以用互斥锁的行为来模拟，但如果有可观察的值发生变化，您可以用可观察的来启动许多异步任务。我们只使用一个布尔型可观察值，我们只发布一次。

use async_std::task::{sleep, spawn};
use async_observable::Observable;
use futures::join;

#[async_std::main]
async fn main() {
    let mut execute = Observable::new(false);
    let mut execute_fork_one = execute.clone();
    let mut execute_fork_two = execute.clone();

    let task_one = spawn(async move {
        println!("task one started");
        execute_fork_one.next().await;
        println!("task one ran");
    });

    let task_two = spawn(async move {
        println!("task two started");
        execute_fork_two.next().await;
        println!("task two ran");
    });

    join!(
        task_one,
        task_two,
        spawn(async move {
            println!("main task started");

            // run some fancy business logic
            sleep(std::time::Duration::from_millis(100)).await;
            // then release our tasks to do stuff when we are done
            execute.publish(true);

            println!("main task ran");
        })
    );
}

您可能会争论说，您可以在启动某些内容的那一刻就启动任务 - 这是真的，如果您只是想启动子任务，这是一个更好的解决方案。 但如果你想要通知程序中的完全不同的部分，这就会变得很困难。 或者例如，如果您想在任务的一半运行时等待另一个任务所做的事情，然后再继续。

此代码最初由 HUM Systems 发布。这个仓库继续开发这个库，因为他们不幸地停止了开源工作。