Struct lockfree_object_pool::SpinLockObjectPool

pub struct SpinLockObjectPool<T> { /* private fields */ }

ObjectPool use a spin lock over vector to secure multithread access to pull.

The spin lock works like std::sync::Mutex but

• use std::sync::atomic::AtomicBool for synchro
• active waiting

cf wikipedia for more information.

Example

 use lockfree_object_pool::SpinLockObjectPool;

 let pool = SpinLockObjectPool::<u32>::new(
   ||  Default::default(),
   |v| {
     *v = 0;
   }
 );
 let mut item = pool.pull();

 *item = 5;
 let work = *item * 5;

Implementations

impl<T> SpinLockObjectPool<T>

pub fn new<R, I>(init: I, reset: R) -> Self

where R: Fn(&mut T) + Send + Sync + 'static, I: Fn() -> T + Send + Sync + 'static,

Create an new SpinLockObjectPool

Arguments

• init closure to create new item
• reset closure to reset item before reusage

Example

 use lockfree_object_pool::SpinLockObjectPool;

 let pool = SpinLockObjectPool::<u32>::new(
   ||  Default::default(),
   |v| {
     *v = 0;
   }
 );

pub fn pull(&self) -> SpinLockReusable<'_, T>

Create a new element. When the element is dropped, it returns in the pull.

Example

 use lockfree_object_pool::SpinLockObjectPool;

 let pool = SpinLockObjectPool::<u32>::new(
   ||  Default::default(),
   |v| {
     *v = 0;
   }
 );
 let mut item = pool.pull();

pub fn pull_owned(self: &Arc<Self>) -> SpinLockOwnedReusable<T>

Create a new element. When the element is dropped, it returns in the pull.

Example

 use lockfree_object_pool::SpinLockObjectPool;
 use std::sync::Arc;

 let pool = Arc::new(SpinLockObjectPool::<u32>::new(
   ||  Default::default(),
   |v| {
     *v = 0;
   }
 ));
 let mut item = pool.pull_owned();