C++内存池

一、内存池的介绍

内存池简单说，是为了减少频繁使用 malloc/free new/delete 等系统调用，造成的性能损耗而设计的。当我们的程序需要频繁地申请和释放内存时，频繁地使用内存管理的系统调用可能会造成性能的瓶颈。内存池的思想是预先申请一大块内存来做一个内存池，之后把内存管理放在应用层执行，当内存池不足时再向系统申请内存，减少系统调用的开销。

我们知道malloc是标准库函数，真正的申请内存动作需要操作系统完成。所以由应用程序到操作系统就需要三层（应用层，标准库，操作系统）。内存池是专为应用程序提供的专属的内存管理器，它属于应用程序层。所以程序申请内存的时候就不需要通过标准库和操作系统，明显降低了开销。

二、设计一个内存池

内存池是一个一个的 block（内存块） 以链表的形式连接起来的。每一个 block 是一块大的内存，当内存池的大小不够分配时，就会向操作系统申请新的block 加入链表。然后在当前block内部，维护一个 freeSlots_ 的链表来记录当前空闲内存单元的位置，该链表的每一项都是对象被释放后归还给内存池的空间。内存池刚创建时freeSlots_ 是空的，之后随着用户创建对象，再将对象释放掉，这时候要把内存归还给内存池，怎么归还呢？就是把指向这个对象的内存的指针加到freeSlots_ 链表的前面。

用户在创建对象的时候，先检查 freeSlots_链表是否为空，不为空（表示有空闲内存）的时候直接取出一项作为分配出的空间，将该地址返回，并且将头信息里的空闲单元改成下一个空闲单元。如果 freeSlots_链表为空（表示没有空闲内存），那就在当前 block 内取出一个 Slot_ 大小的内存分配出去，如果 block 里面的内存已经使用完了呢？就向操作系统申请一个新的 block。内存池工作期间的内存只会增长，并不释放给操作系统。最后直到内存池销毁的时候，才把所有的 block delete 掉。

 三、实现

我们模仿STL的allocator 来实现，先定义标准接口

memory.h

#ifndef MEMORY_POOL_H
#define MEMORY_POOL_H
 
#include <climits>
#include <cstddef>
 
template <typename T, size_t BlockSize = 4096>
class MemoryPool
{
public:
  /* Member types */
  typedef T value_type;
  typedef T *pointer;
  typedef T &reference;
  typedef const T *const_pointer;
  typedef const T &const_reference;
  typedef std::size_t size_type;
  typedef std::ptrdiff_t difference_type;
  typedef std::false_type propagate_on_container_copy_assignment;
  typedef std::true_type propagate_on_container_move_assignment;
  typedef std::true_type propagate_on_container_swap;
 
  template <typename U>
  struct rebind
  {
    typedef MemoryPool<U> other;
  };
 
  /* Member functions */
  MemoryPool() noexcept;
  MemoryPool(const MemoryPool &memoryPool) noexcept;
  MemoryPool(MemoryPool &&memoryPool) noexcept;
  template <class U>
  MemoryPool(const MemoryPool<U> &memoryPool) noexcept;
 
  ~MemoryPool() noexcept;
 
  MemoryPool &operator=(const MemoryPool &memoryPool) = delete;
  MemoryPool &operator=(MemoryPool &&memoryPool) noexcept;
 
  pointer address(reference x) const noexcept;
  const_pointer address(const_reference x) const noexcept;
 
  // Can only allocate one object at a time. n and hint are ignored
  pointer allocate(size_type n = 1, const_pointer hint = 0);
  void deallocate(pointer p, size_type n = 1);
 
  size_type max_size() const noexcept;
 
  template <class U, class... Args>
  void construct(U *p, Args &&... args);
  template <class U>
  void destroy(U *p);
 
  template <class... Args>
  pointer newElement(Args &&... args);
  void deleteElement(pointer p);
 
private:
  union Slot_
  {
    value_type element;
    Slot_ *next;
  };
 
  typedef char *data_pointer_;
  typedef Slot_ slot_type_;
  typedef Slot_ *slot_pointer_;
 
  slot_pointer_ currentBlock_;
  slot_pointer_ currentSlot_;
  slot_pointer_ lastSlot_;
  slot_pointer_ freeSlots_;
 
  size_type padPointer(data_pointer_ p, size_type align) const noexcept;
  void allocateBlock();
 
  static_assert(BlockSize >= 2 * sizeof(slot_type_), "BlockSize too small.");
};
 
#endif // MEMORY_POOL_H

MemoryPool.cpp

#ifndef MEMORY_BLOCK_TCC
#define MEMORY_BLOCK_TCC
 
#include "MemoryPool.h"
 
template <typename T, size_t BlockSize>
inline typename MemoryPool<T, BlockSize>::size_type
MemoryPool<T, BlockSize>::padPointer(data_pointer_ p, size_type align)
    const noexcept
{
  uintptr_t result = reinterpret_cast<uintptr_t>(p);
  return ((align - result) % align);
}
 
template <typename T, size_t BlockSize>
MemoryPool<T, BlockSize>::MemoryPool() noexcept
{
  currentBlock_ = nullptr;
  currentSlot_ = nullptr;
  lastSlot_ = nullptr;
  freeSlots_ = nullptr;
}
 
template <typename T, size_t BlockSize>
MemoryPool<T, BlockSize>::MemoryPool(const MemoryPool &memoryPool) noexcept : MemoryPool()
{
}
 
template <typename T, size_t BlockSize>
MemoryPool<T, BlockSize>::MemoryPool(MemoryPool &&memoryPool) noexcept
{
  currentBlock_ = memoryPool.currentBlock_;
  memoryPool.currentBlock_ = nullptr;
  currentSlot_ = memoryPool.currentSlot_;
  lastSlot_ = memoryPool.lastSlot_;
  freeSlots_ = memoryPool.freeSlots;
}
 
template <typename T, size_t BlockSize>
template <class U>
MemoryPool<T, BlockSize>::MemoryPool(const MemoryPool<U> &memoryPool) noexcept : MemoryPool()
{
}
 
template <typename T, size_t BlockSize>
MemoryPool<T, BlockSize> &
MemoryPool<T, BlockSize>::operator=(MemoryPool &&memoryPool) noexcept
{
  if (this != &memoryPool)
  {
    std::swap(currentBlock_, memoryPool.currentBlock_);
    currentSlot_ = memoryPool.currentSlot_;
    lastSlot_ = memoryPool.lastSlot_;
    freeSlots_ = memoryPool.freeSlots;
  }
  return *this;
}
 
template <typename T, size_t BlockSize>
MemoryPool<T, BlockSize>::~MemoryPool() noexcept
{
  slot_pointer_ curr = currentBlock_;
  while (curr != nullptr)
  {
    slot_pointer_ prev = curr->next;
    operator delete(reinterpret_cast<void *>(curr));
    curr = prev;
  }
}
 
template <typename T, size_t BlockSize>
inline typename MemoryPool<T, BlockSize>::pointer
MemoryPool<T, BlockSize>::address(reference x)
    const noexcept
{
  return &x;
}
 
template <typename T, size_t BlockSize>
inline typename MemoryPool<T, BlockSize>::const_pointer
MemoryPool<T, BlockSize>::address(const_reference x)
    const noexcept
{
  return &x;
}
 
template <typename T, size_t BlockSize>
void MemoryPool<T, BlockSize>::allocateBlock()
{
  // Allocate space for the new block and store a pointer to the previous one
  data_pointer_ newBlock = reinterpret_cast<data_pointer_>(operator new(BlockSize));
  reinterpret_cast<slot_pointer_>(newBlock)->next = currentBlock_;
  currentBlock_ = reinterpret_cast<slot_pointer_>(newBlock);
  // Pad block body to staisfy the alignment requirements for elements
  data_pointer_ body = newBlock + sizeof(slot_pointer_);
  size_type bodyPadding = padPointer(body, alignof(slot_type_));
  currentSlot_ = reinterpret_cast<slot_pointer_>(body + bodyPadding);
  lastSlot_ = reinterpret_cast<slot_pointer_>(newBlock + BlockSize - sizeof(slot_type_) + 1);
}
 
template <typename T, size_t BlockSize>
inline typename MemoryPool<T, BlockSize>::pointer
MemoryPool<T, BlockSize>::allocate(size_type n, const_pointer hint)
{
  if (freeSlots_ != nullptr)
  {
    pointer result = reinterpret_cast<pointer>(freeSlots_);
    freeSlots_ = freeSlots_->next;
    return result;
  }
  else
  {
    if (currentSlot_ >= lastSlot_)
      allocateBlock();
    return reinterpret_cast<pointer>(currentSlot_++);
  }
}
 
template <typename T, size_t BlockSize>
inline void
MemoryPool<T, BlockSize>::deallocate(pointer p, size_type n)
{
  if (p != nullptr)
  {
    reinterpret_cast<slot_pointer_>(p)->next = freeSlots_;
    freeSlots_ = reinterpret_cast<slot_pointer_>(p);
  }
}
 
template <typename T, size_t BlockSize>
inline typename MemoryPool<T, BlockSize>::size_type
MemoryPool<T, BlockSize>::max_size()
    const noexcept
{
  size_type maxBlocks = -1 / BlockSize;
  return (BlockSize - sizeof(data_pointer_)) / sizeof(slot_type_) * maxBlocks;
}
 
template <typename T, size_t BlockSize>
template <class U, class... Args>
inline void
MemoryPool<T, BlockSize>::construct(U *p, Args &&... args)
{
  new (p) U(std::forward<Args>(args)...);
}
 
template <typename T, size_t BlockSize>
template <class U>
inline void
MemoryPool<T, BlockSize>::destroy(U *p)
{
  p->~U();
}
 
template <typename T, size_t BlockSize>
template <class... Args>
inline typename MemoryPool<T, BlockSize>::pointer
MemoryPool<T, BlockSize>::newElement(Args &&... args)
{
  pointer result = allocate();
  construct<value_type>(result, std::forward<Args>(args)...);
  return result;
}
 
template <typename T, size_t BlockSize>
inline void
MemoryPool<T, BlockSize>::deleteElement(pointer p)
{
  if (p != nullptr)
  {
    p->~value_type();
    deallocate(p);
  }
}
 
#endif // MEMORY_BLOCK_TCC

源码：

https://github.com/cacay/MemoryPool

参考：

内存池（memory pool）_书笑生的博客-CSDN博客_内存池

C++11实现高效内存池 - nepu_bin - 博客园