Tokio Notify Aggregator

tokio_notify_aggregator 是一个 Rust 库，提供了一种机制，可以将多个 Tokio Notify 实例聚合到一个单个的通知源。这允许高效地等待来自一组 Notify 实例的通知。

特性

• 将多个 Notify 实例聚合到一个单个流中。
• 模仿 Notify 的 API，易于使用。

安装

将 tokio_notify_aggregator 添加到您的 Cargo.toml

[dependencies]
tokio_notify_aggregator = "*"  # Use the latest version

使用方法

一旦 Notify 实例被添加到聚合器中，就可以像使用单个 Notify 实例一样使用聚合器来等待通知。下面的（略微冗长的）示例演示了这一点——三个 Notify 实例被添加到聚合器中，并在不同时间触发。然后使用聚合器等待来自任一实例的通知。

use tokio::sync::Notify;
use tokio_notify_aggregator::NotifyAggregator;
use std::sync::Arc;
use std::time::Duration;

#[tokio::main]
async fn main() {
    let notify1 = Arc::new(Notify::new());
    let notify2 = Arc::new(Notify::new());
    let notify3 = Arc::new(Notify::new());

    let mut aggregator = NotifyAggregator::new();
    aggregator.add_notifier(notify1.clone());
    aggregator.add_notifier(notify2.clone());
    aggregator.add_notifier(notify3.clone());

    // Notify all three instances
    tokio::spawn(async move {
        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
        notify1.notify_waiters();
    });
    tokio::spawn(async move {
        tokio::time::sleep(std::time::Duration::from_secs(2)).await;
        notify2.notify_waiters();
    });
    tokio::spawn(async move {
        tokio::time::sleep(std::time::Duration::from_secs(3)).await;
        notify3.notify_waiters();
    });

    // Wait for notifications
    aggregator.notified().await;
    println!("Notified");
    aggregator.notified().await;
    println!("Notified");
    aggregator.notified().await;
    println!("Notified");
    match tokio::time::timeout(Duration::from_millis(500), aggregator.notified()).await {
        Ok(_) => panic!("Should not have been notified"),
        Err(_) => println!("Timed out"),
    }
}

聚合器可以以多种方式构建

use tokio_notify_aggregator::NotifyAggregator;
use tokio::sync::Notify;
use std::sync::Arc;

#[tokio::main]
async fn main() {
    // Construct an aggregator with a single Notify instance
    let notify = Arc::new(Notify::new());
    let aggregator = NotifyAggregator::new();
    aggregator.add_notifier(notify);

    // Construct an aggregator from a vector of Notify instances
    let notify1 = Arc::new(Notify::new());
    let notify2 = Arc::new(Notify::new());
    let notify3 = Arc::new(Notify::new());
    let aggregator = NotifyAggregator::from_vec(&vec![notify1, notify2, notify3]);

    // Construct an aggregator from any iterator of Notify instances
    let notify1 = Arc::new(Notify::new());
    let notify2 = Arc::new(Notify::new());
    let notify3 = Arc::new(Notify::new());
    let aggregator = NotifyAggregator::from_iter([notify1, notify2, notify3]);
    
    // Construct a temporary aggregator
    let notify1 = Arc::new(Notify::new());
    let notify2 = Arc::new(Notify::new());
    NotifyAggregator::new()
        .add_notifier(notify1)
        .add_notifier(notify2)
        .notified()
        .await; // Will wait for notification from notify1 or notify2
}

更多示例

• 两个简单的通知器：示例在这里

• 多个同时通知器：示例在这里

有关更详细的使用和示例，请参阅文档。