Struct Notify 

pub struct Notify { /* private fields */ }

A notify primitive for signaling events.

Notify provides a mechanism for tasks to wait for events and for other tasks to signal those events. It is similar to a condition variable but designed for async/await.

Example

let notify = Notify::new();

// Spawn a task that waits for notification
let fut = async {
    notify.notified().await;
    println!("notified!");
};

// Later, signal the waiter
notify.notify_one();

Implementations

impl Notify

pub fn new() -> Self

Creates a new Notify in the empty state.

pub fn notified(&self) -> Notified<'_>

Returns a future that completes when this Notify is notified.

The returned future is cancel-safe: if dropped before completion, the waiter is cleanly removed.

Example

use asupersync::sync::Notify;
use std::sync::{
    Arc,
    atomic::{AtomicBool, Ordering},
};

let notify = Arc::new(Notify::new());
let ready = Arc::new(AtomicBool::new(false));

let signaler = {
    let notify = Arc::clone(&notify);
    let ready = Arc::clone(&ready);

    std::thread::spawn(move || {
        ready.store(true, Ordering::Release);
        notify.notify_one();
    })
};

notify.notified().await;
assert!(ready.load(Ordering::Acquire));
signaler.join().expect("signaler thread panicked");

pub async fn wait_until<F>(&self, predicate: F)

where F: FnMut() -> bool,

Waits until predicate returns true, re-checking it after every wake.

The predicate is evaluated before parking and again after each notification, so callers can pair a state transition with notify_one() / notify_waiters() without a separate check-then-park race window.

Example

use asupersync::sync::Notify;
use std::sync::{
    Arc,
    atomic::{AtomicBool, Ordering},
};

let notify = Arc::new(Notify::new());
let ready = Arc::new(AtomicBool::new(false));

let signaler = {
    let notify = Arc::clone(&notify);
    let ready = Arc::clone(&ready);

    std::thread::spawn(move || {
        ready.store(true, Ordering::Release);
        notify.notify_one();
    })
};

notify
    .wait_until(|| ready.load(Ordering::Acquire))
    .await;
assert!(ready.load(Ordering::Acquire));
signaler.join().expect("signaler thread panicked");

pub fn notify_one(&self) -> bool

Notifies one waiting task.

If no task is currently waiting, the notification is stored and will be delivered to the next task that calls notified().await.

If multiple tasks are waiting, exactly one will be woken.

Returns true when an active waiter was selected and woken, or false when no waiter was available and the notification was stored.

pub fn notify_waiters(&self)

Notifies all waiting tasks.

This wakes all tasks that are currently waiting. Tasks that start waiting after this call will not be affected.

pub fn waiter_count(&self) -> usize

Returns the number of tasks currently waiting.

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

Returns the “default value” for a type.

impl Drop for Notify

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.