Struct async_notify::Notify

pub struct Notify { /* fields omitted */ }

Notify a single task to wake up.

Notify provides a basic mechanism to notify a single task of an event. Notify itself does not carry any data. Instead, it is to be used to signal another task to perform an operation.

If notify() is called before notified().await, then the next call to notified().await will complete immediately, consuming the permit. Any subsequent calls to notified().await will wait for a new permit.

If notify() is called multiple times before notified().await, only a single permit is stored. The next call to notified().await will complete immediately, but the one after will wait for a new permit.

Examples

Basic usage.

use async_notify::Notify;

#[async_std::main]
async fn main() {
    let notify = Notify::new();
    let notify2 = notify.clone();

    async_std::task::spawn(async move {
        notify2.notified().await;
        println!("received notification");
    });

    println!("sending notification");
    notify.notify();
}

Methods

impl Notify

Like tokio Notify, this is a async-std version Notify and implement Clone.

pub fn new() -> Self

pub fn notify(&self)

Notifies a waiting task

If a task is currently waiting, that task is notified. Otherwise, a permit is stored in this Notify value and the next call to notified().await will complete immediately consuming the permit made available by this call to notify().

At most one permit may be stored by Notify. Many sequential calls to notify will result in a single permit being stored. The next call to notified().await will complete immediately, but the one after that will wait.

Examples

use async_notify::Notify;

#[async_std::main]
async fn main() {
    let notify = Notify::new();
    let notify2 = notify.clone();

    async_std::task::spawn(async move {
        notify2.notified().await;
        println!("received notification");
    });

    println!("sending notification");
    notify.notify();
}

pub async fn notified<'_>(&'_ self)

Wait for a notification.

Each Notify value holds a single permit. If a permit is available from an earlier call to notify(), then notified().await will complete immediately, consuming that permit. Otherwise, notified().await waits for a permit to be made available by the next call to notify().

Examples

use async_notify::Notify;

#[async_std::main]
async fn main() {
    let notify = Notify::new();
    let notify2 = notify.clone();

    async_std::task::spawn(async move {
        notify2.notified().await;
        println!("received notification");
    });

    println!("sending notification");
    notify.notify();
}

Trait Implementations

impl Clone for Notify

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for Notify

fn default() -> Notify

Returns the "default value" for a type.