Struct Notify

pub struct Notify { /* private fields */ }

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_global_executor::block_on(async {
   let notify = Arc::new(Notify::new());
   let notify2 = notify.clone();

   async_global_executor::spawn(async move {
       notify2.notify();
       println!("sent notification");
   })
   .detach();

   println!("received notification");
   notify.notified().await;
})

Implementations

impl Notify

Like tokio Notify, this is a runtime independent 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_global_executor::block_on(async {
   let notify = Arc::new(Notify::new());
   let notify2 = notify.clone();

   async_global_executor::spawn(async move {
       notify2.notify();
       println!("sent notification");
   })
   .detach();

   println!("received notification");
   notify.notified().await;
})

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().

This method is cancel safety.

Trait Implementations

impl<T: Deref<Target = Notify>> AsRef<Notify> for NotifyStream<T>

fn as_ref(&self) -> &Notify

Converts this type into a shared reference of the (usually inferred) input type.

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.