Struct WaitQueue 

pub struct WaitQueue { /* private fields */ }

A queue to store sleeping tasks.

Examples

use core::sync::atomic::{AtomicU32, Ordering};

use ax_task::WaitQueue;

static VALUE: AtomicU32 = AtomicU32::new(0);
static WQ: WaitQueue = WaitQueue::new();

ax_task::init_scheduler();
// spawn a new task that updates `VALUE` and notifies the main task
ax_task::spawn(|| {
    assert_eq!(VALUE.load(Ordering::Acquire), 0);
    VALUE.fetch_add(1, Ordering::Release);
    WQ.notify_one(true); // wake up the main task
});

WQ.wait(); // block until `notify()` is called
assert_eq!(VALUE.load(Ordering::Acquire), 1);

Implementations

impl WaitQueue

pub const fn new() -> Self

Creates an empty wait queue.

pub fn is_empty(&self) -> bool

Returns whether this queue currently contains no blocked tasks.

pub fn wait(&self)

Blocks the current task and put it into the wait queue, until other task notifies it.

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

where F: Fn() -> bool,

Blocks the current task and put it into the wait queue, until the given condition becomes true.

Note that even other tasks notify this task, it will not wake up until the condition becomes true.

pub fn wait_timeout(&self, dur: Duration) -> bool

Blocks the current task and put it into the wait queue, until other tasks notify it, or the given duration has elapsed.

pub fn wait_timeout_until<F>(&self, dur: Duration, condition: F) -> bool

where F: Fn() -> bool,

Blocks the current task and put it into the wait queue, until the given condition becomes true, or the given duration has elapsed.

Note that even other tasks notify this task, it will not wake up until the above conditions are met.

pub fn notify_one(&self, resched: bool) -> bool

Wakes up one task in the wait queue, usually the first one. If resched is true, the current task will be preempted when the preemption is enabled.

pub fn notify_one_from_irq(&self) -> bool

Wakes up one task from IRQ context.

This method is intended for low-level deferred notification paths. It only unblocks the worker and marks the current task for rescheduling after IRQ/preemption guards are released; it must not be used as a substitute for publishing the condition that the waiter will observe.

pub fn notify_one_with<F>(&self, resched: bool, func: F) -> bool

where F: Fn(u64),

Wakes up one task in the wait queue and runs a callback on it.

The callback func is invoked while holding the wait-queue lock and before the selected task is unblocked. It receives the task’s ID as a u64 when a task is available, or 0 if the wait queue is empty. This can be used for lock handoff or other bookkeeping associated with the waking task.

If resched is true, the current task will be preempted when the preemption is enabled.

pub fn notify_all(&self, resched: bool)

Wakes all tasks in the wait queue.

If resched is true, the current task will yield.

pub fn notify_all_from_irq(&self)

Wakes all tasks from IRQ context.

This method is intended for low-level deferred notification paths. It only unblocks workers and marks the current task for rescheduling after IRQ/preemption guards are released; it must not be used as a substitute for publishing the condition that waiters will observe.

Trait Implementations

impl Default for WaitQueue

fn default() -> Self

Returns the “default value” for a type.