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 std::sync::Arc;
use async_notify::Notify;

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

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

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

Implementations

impl Notify

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

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 std::sync::Arc;
use async_notify::Notify;

#[async_std::main]
async fn main() {
    let notify = Arc::new(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 std::sync::Arc;
use async_notify::Notify;

#[async_std::main]
async fn main() {
    let notify = Arc::new(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 Debug for Notify

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Default for Notify

fn default() -> Notify

Returns the "default value" for a type.

impl Stream for Notify

type Item = ()

Values yielded by the stream.

fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.