Struct AsyncQueue 

pub struct AsyncQueue<T> {
    queue: Mutex<VecDeque<T>>,
    capacity: usize,
    not_empty: CondVar,
    not_full: CondVar,
}

Bounded async queue. Producers push (blocks while full), consumers recv (blocks while empty).

The mutex covers only the VecDeque push/pop, so slow work the consumer does after recv is never inside a lock.

Example

use karyon_core::async_util::AsyncQueue;

async {
    let q = AsyncQueue::<u32>::new(8);
    q.push(1).await;
    let _ = q.recv().await;
};

Fields

queue: Mutex<VecDeque<T>>

capacity: usize

not_empty: CondVar

not_full: CondVar

Implementations

impl<T> AsyncQueue<T>

pub fn new(capacity: usize) -> Arc<Self>

Create an AsyncQueue with the given capacity. Panics if capacity is zero.

pub async fn push(&self, item: T)

Push an item. Awaits while the queue is full.

pub async fn recv(&self) -> T

Pop the next item. Awaits while the queue is empty.

pub async fn len(&self) -> usize

Current number of items.

pub async fn is_empty(&self) -> bool

True when the queue has no items.

pub fn capacity(&self) -> usize

Configured capacity.