Struct LockFreePool 

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

Available on crate features std and lock-free only.

A lock-free memory pool using atomic operations.

This pool provides better performance under high contention compared to ThreadSafePool by avoiding locks. Requires the lock-free feature.

Examples

use fastalloc::LockFreePool;
use std::sync::Arc;
use std::thread;

let pool = Arc::new(LockFreePool::<i32>::new(1000).unwrap());

let mut handles = vec![];
for i in 0..8 {
    let pool_clone = Arc::clone(&pool);
    handles.push(thread::spawn(move || {
        for j in 0..100 {
            let _handle = pool_clone.allocate(i * 100 + j).unwrap();
        }
    }));
}

for handle in handles {
    handle.join().unwrap();
}

Implementations

impl<T> LockFreePool<T>

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

Creates a new lock-free pool with the specified capacity.

Note: The current implementation is a simplified version. A full production implementation would use a more sophisticated lock-free data structure.

pub fn with_initializer<F>(capacity: usize, init: F) -> Result<Self>

where F: FnMut() -> T,

Pre-populates the pool with objects created by the initializer.

pub fn try_allocate(&self) -> Option<Box<T>>

Attempts to allocate an object from the pool.

If the pool is empty, this will fail. Unlike other pool types, this simplified lock-free implementation does not automatically grow.

pub fn return_object(&self, object: Box<T>)

Returns an object to the pool.

Trait Implementations

impl<T> Clone for LockFreePool<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Send> Send for LockFreePool<T>

impl<T: Send> Sync for LockFreePool<T>