object_pool.hpp

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <memory>
#include <mutex>
#include <queue>
#include <stdexcept>  // For potential exceptions if needed
#include <vector>  // Alternative storage
 
namespace toolbox::base
{
 
template<typename T>
class object_pool_t;  // Forward declaration
 
template<typename T>
class PoolDeleter
{
  object_pool_t<T>* pool_ =
      nullptr;  // 指向对象池的非拥有指针/Non-owning pointer to the pool
 
public:
  explicit PoolDeleter(object_pool_t<T>* pool = nullptr)
      : pool_(pool)
  {
  }
 
  void operator()(T* ptr) const
  {
    if (pool_ && ptr) {
      pool_->release(ptr);  // 告诉池回收对象/Tell the pool to take it back
    } else {
      // 如果没有关联的池,执行默认删除/If no pool is associated, perform default
      // delete 处理在池外创建新对象或池过早销毁的情况/This handles cases where
      // acquire might create a new object outside the pool's direct management
      // or if the pool is destroyed early
      delete ptr;
    }
  }
};
 
template<typename T>
class object_pool_t
{
public:
  using PooledObjectPtr = std::unique_ptr<T, PoolDeleter<T>>;
 
  explicit object_pool_t(size_t initial_size = 0,
                         std::function<void(T&)> resetter = nullptr)
      : reset_func_(std::move(resetter))
  {
    for (size_t i = 0; i < initial_size; ++i) {
      pool_.push(std::make_unique<T>());
    }
  }
 
  // 为简单起见删除复制/移动操作/Deleted copy/move operations for simplicity
  object_pool_t(const object_pool_t&) = delete;
  object_pool_t& operator=(const object_pool_t&) = delete;
  object_pool_t(object_pool_t&&) = delete;
  object_pool_t& operator=(object_pool_t&&) = delete;
 
  PooledObjectPtr acquire()
  {
    std::unique_ptr<T> obj_ptr = nullptr;  // 用于临时所有权的 unique_ptr/Use
                                           // unique_ptr for temporary ownership
 
    {  // 锁作用域/Lock scope
      std::lock_guard<std::mutex> lock(mutex_);
      if (!pool_.empty()) {
        obj_ptr = std::move(pool_.front());  // 从池中取出/Take from pool
        pool_.pop();
      }
    }  // 在可能创建新对象前解锁互斥量/Unlock mutex before potentially creating
       // a new object
 
    if (!obj_ptr) {  // 如果池为空/If pool was empty
      obj_ptr = std::make_unique<T>();  // 创建新对象/Create a new one
    }
 
    // 将对象包装在带自定义删除器的 unique_ptr 中返回/Return the object wrapped
    // in a unique_ptr with our custom deleter
    return PooledObjectPtr(obj_ptr.release(), PoolDeleter<T>(this));
  }
 
  void release(T* ptr)
  {
    if (!ptr)
      return;
 
    // 如果有重置函数则重置对象状态/Reset object state if a reset function is
    // available
    if (reset_func_) {
      try {
        reset_func_(*ptr);
      } catch (const std::exception& e) {
        // 记录错误?不要让重置器的异常破坏池/Log error? Don't let exceptions
        // from resetter break the pool
        // 考虑使用不使用此池的机制进行日志记录/Consider logging using a
        // mechanism that doesn't use this pool
        fprintf(stderr, "[ObjectPool] Exception during reset: %s\n", e.what());
        // 决定是继续池化对象还是删除它/Decide whether to still pool the object
        // or delete it 如果重置严重失败,删除可能更安全/Deleting might be safer
        // if reset failed critically
        delete ptr;
        return;
      } catch (...) {
        fprintf(stderr, "[ObjectPool] Unknown exception during reset.\n");
        delete ptr;
        return;
      }
    }
 
    std::unique_ptr<T> obj_ptr(ptr);  // 重新包装原始指针以管理所有权/Re-wrap
                                      // raw pointer to manage ownership
    {  // 锁作用域/Lock scope
      std::lock_guard<std::mutex> lock(mutex_);
      pool_.push(std::move(obj_ptr));  // 将 unique_ptr 添加回池中/Add
                                       // unique_ptr back to the pool
    }
  }
 
private:
  friend class PoolDeleter<T>;  // 允许删除器调用 release/Allow deleter to call
                                // release
 
  std::queue<std::unique_ptr<T>> pool_;  // 对象池队列/Object pool queue
  mutable std::mutex mutex_;  // 用于线程安全的互斥量/Mutex for thread safety
  std::function<void(T&)> reset_func_;  // 对象重置函数/Object reset function
};
 
}  // namespace toolbox::base