memory_pool.hpp

Go to the documentation of this file.

#include <cstddef>  
#include <limits>  
#include <mutex>  
#include <queue>  
#include <stdexcept>  
 
#include <cpp-toolbox/macro.hpp>
 
namespace toolbox::base
{
 
class memory_pool_t
{
public:
  explicit memory_pool_t(
      std::size_t block_size,
      std::size_t initial_blocks = 0,
      std::size_t max_cached_blocks = std::numeric_limits<std::size_t>::max(),
      std::size_t growth = 1)
      : block_size_(block_size)
      , growth_(growth == 0 ? 1 : growth)
      , max_cached_blocks_(max_cached_blocks)
  {
    if (block_size_ == 0) {
      throw std::invalid_argument("block size must be > 0");
    }
 
    // 预分配指定数量的内存块/Preallocate the specified number of blocks
    for (std::size_t i = 0; i < initial_blocks; ++i) {
      pool_.push(::operator new(block_size_));
    }
  }
 
  ~memory_pool_t() { release_unused(); }
 
  CPP_TOOLBOX_DISABLE_COPY(memory_pool_t)
  CPP_TOOLBOX_DISABLE_MOVE(memory_pool_t)
 
  
  void* allocate()
  {
    std::lock_guard<std::mutex> lock(mutex_);
    if (pool_.empty()) {
      expand_blocks(growth_);
    }
    void* ptr = pool_.front();
    pool_.pop();
    return ptr;
  }
 
  void deallocate(void* ptr)
  {
    if (!ptr) {
      return;
    }
    std::lock_guard<std::mutex> lock(mutex_);
    if (pool_.size() >= max_cached_blocks_) {
      ::operator delete(ptr);
    } else {
      pool_.push(ptr);
    }
  }
 
  std::size_t block_size() const noexcept { return block_size_; }
 
  std::size_t free_blocks() const
  {
    std::lock_guard<std::mutex> lock(mutex_);
    return pool_.size();
  }
 
  void release_unused()
  {
    std::lock_guard<std::mutex> lock(mutex_);
    // 释放所有缓存块/Release all cached blocks
    while (!pool_.empty()) {
      ::operator delete(pool_.front());
      pool_.pop();
    }
  }
 
private:
  std::size_t block_size_ {};
  std::size_t growth_ {1};
  std::size_t max_cached_blocks_ {std::numeric_limits<std::size_t>::max()};
  mutable std::mutex mutex_;
  std::queue<void*> pool_;
 
  void expand_blocks(std::size_t count)
  {
    for (std::size_t i = 0; i < count; ++i) {
      pool_.push(::operator new(block_size_));
    }
  }
};
 
}  // namespace toolbox::base