Struct BlockingQueue 

pub struct BlockingQueue<'a, T> { /* private fields */ }

A thread safe blocking queue. Objects are added to the queue via a closure and are owned by the queue as well This means objects in the queue will only be dropped when the queue’s backing buffer is also destroyed.

Implementations

impl<'a, T> BlockingQueue<'a, T>

 use rustpool::BlockingQueue;
 use rustpool::RPQueue;

 fn main() {
   let new_value: isize = 1;

    // create a blocking queue with 3 elements set to value 0
    let q = BlockingQueue::<isize>::new(3, || 0);

    println!("simple blocking queue size {}", q.capacity());

    // take the first element
    let v1 = q.take().unwrap();

    println!("first element is {}", v1);

    // remove the remaining items
    let v2 = q.take().unwrap();
    let v3 = q.take().unwrap();

    // how many items available now?
    println!("items in the queue {}", q.available());

    // no more items to return, let's wait at most one second
    let empty = q.take_wait(std::time::Duration::from_secs(1));

    assert_eq!(None, empty);

    // put everything back
    q.offer(v1);
    q.offer(v2);
    q.offer(v3);

    // how many items available now?
    println!("items in the queue {}", q.available());

    // we can't add more items than the original capacity
    q.offer(&new_value);

    // we still have the same number of available items
    println!("items in the queue {}", q.available());
}

pub fn new(size: usize, f: impl FnMut() -> T) -> Self

Create a new queue with fixed size size using custom create function

Examples found in repository

examples/blocking_queue.rs (line 9)

fn main() {
    let new_value: isize = 1;

    // create a blocking queue with 3 elements set to value 0
    let q = BlockingQueue::<isize>::new(3, || 0);

    println!("simple blocking queue size {}", q.capacity());

    // take the first element
    let v1 = q.take().unwrap();

    println!("first element is {}", v1);

    // remove the remaining items
    let v2 = q.take().unwrap();
    let v3 = q.take().unwrap();

    // how many items available now?
    println!("items in the queue {}", q.available());

    // no more items to return, let's wait at most one second
    let empty = q.take_wait(std::time::Duration::from_secs(1));

    assert_eq!(None, empty);

    // put everything back
    q.offer(v1);
    q.offer(v2);
    q.offer(v3);

    // how many items available now?
    println!("items in the queue {}", q.available());

    // we can't add more items than the original capacity
    q.offer(&new_value);

    // we still have the same number of available items
    println!("items in the queue {}", q.available());
}

pub fn new_arc(size: usize, f: impl FnMut() -> T) -> Arc<Self>

Create a new queue with fixed size wrapped as an atomic reference counter using a custom create function

Trait Implementations

impl<'a, T> Drop for BlockingQueue<'a, T>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T> RPQueue<'a, T> for BlockingQueue<'a, T>

fn capacity(&self) -> usize

Returns the size of the queue in total number objects originally allocated

fn available(&self) -> usize

Returns the number of available items in the buffer

fn take(&self) -> Option<&'a mut T>

Returns an object from the queue or None if the pool is empty. This method allows a race when checking if the pool is empty in order to quickly exit without causing lock contention. This method is preferred over BlockingQueue::take_wait when empty or near empty pools are common.

fn take_wait(&self, timeout: Duration) -> Option<&'a mut T>

Returns an object from the queue or block until one is available

fn offer(&self, item: &'a T) -> usize

Returns an object to the pool

impl<'a, T> Send for BlockingQueue<'a, T>

impl<'a, T> Sync for BlockingQueue<'a, T>