无锁对象池

一个线程安全的对象池集合，具有自动返回。

某些实现是无锁的

• LinearObjectPool
• SpinLockObjectPool

其他使用 std::Mutex

• MutexObjectPool

和 NoneObjectPool 基本分配，没有池。

用法

[dependencies]
lockfree-object-pool = "0.1"

extern crate lockfree_object_pool;

示例

一般池创建如下

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

并使用对象池

  let mut item = pool.pull();
  *item = 5;
  ...  

作用域结束时，项目返回到对象池。

接口

所有实现都支持相同的接口

struct ObjectPool<T> {  
}

impl<T> ObjectPool<T> {
  // for LinearObjectPool, SpinLockObjectPool and MutexObjectPool
  // init closure used to create an element
  // reset closure used to reset element a dropped element
  pub fn new<R, I>(init: I, reset: R) -> Self
    where
        R: Fn(&mut T) + 'static + Send + Sync,
        I: Fn() -> T + 'static + Send + Sync + Clone,
    {
      ...
    }

  // for NoneObjectPool
  // init closure used to create an element
  pub fn new<I>(init: I) -> Self
    where
        I: Fn() -> T + 'static
    {
      ...
    }

  pub fn pull(&self) -> Reusable<T> {
    ...
  }

  pub fn pull_owned(self: &Arc<Self>) -> OwnedReusable<T> {
    ...
  }
}

struct Reusable<T> {  
}

impl<'a, T> DerefMut for Reusable<'a, T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        ...
    }
}

impl<'a, T> Deref for Reusable<'a, T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        ...
    }
}

struct OwnedReusable<T> {  
}

impl<'a, T> DerefMut for OwnedReusable<'a, T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        ...
    }
}

impl<'a, T> Deref for OwnedReusable<'a, T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        ...
    }
}

多线程

所有实现都支持从一个或多个线程进行分配/释放。您只需要将池包装在 std::sync::Arc

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

性能

全局 报告。

分配

报告 单线程 和 多线程

线程间转发消息

不支持 crate 'object-pool'

报告 1-1，5-1，1-5，5-5

资源释放

报告 单线程 和 多线程

与类似库的比较

• crate 'sharded-slab'：我喜欢提取接口，但不喜欢

  • 默认/重置特性，因为它不够灵活
  • 性能
  • create_owned 方法没有在 Self 上使用引用

• crate 'object-pool'：使用自旋锁进行同步，性能相当不错，但我不喜欢

  • 需要在每次提取时指定回退

  use object_pool::Pool;
  let pool = Pool::<Vec<u8>>::new(32, || Vec::with_capacity(4096);
  // ...
  let item1 = pool.pull(|| Vec::with_capacity(4096));
  // ...
  let item2 = pool.pull(|| Vec::with_capacity(4096));
  

  • 没有重置机制，需要手动操作
  • 没有在线程间转发数据的能力

待办事项

• 为什么带有自旋锁的对象池性能比 crate 'object-pool' 使用自旋锁互斥锁差这么多
• 实现一个树形对象池（参考 toolsbox）

实现细节

待办事项

许可

参考 Boost 许可证

相关项目

• crate 'object-pool' - 使用互斥锁的 Rust 线程安全对象池
• crate 'sharded-slab' - 无锁并发块
• toolsbox - 一些 C++ 对象池实现