在现代高性能应用中，频繁的内存分配与释放往往成为瓶颈。C++标准库提供的operator new与operator delete在大多数情况下表现良好，但当需求是大量相同大小对象的快速创建与销毁时，内存池（Memory Pool）可以显著提升性能。本文将从内存池的设计理念出发，展示一个轻量级的C++实现，并讨论其在多线程环境中的应用与扩展。
1. 内存池的基本思想
内存池是预先分配一大块连续内存，然后在此块中按需切分成若干固定大小或可变大小的块。使用者从池中取出一个块进行初始化，然后在不需要时将其归还池中，而不是直接返回系统。这样可以：
- 减少系统调用：一次性分配大块内存，避免频繁的
malloc/free。 - 降低碎片：统一块大小减少碎片化。
- 提升缓存命中率：相邻块在同一物理页，改善局部性。
- 实现快速分配/释放：只需在链表中插入/删除节点即可。
2. 基础实现：单线程固定大小内存池
下面给出一个最简易的固定大小内存池实现，使用链表维护空闲块。
#include <cstddef>
#include <new>
#include <cassert>
class FixedSizePool {
public:
explicit FixedSizePool(std::size_t blockSize, std::size_t poolSize)
: blockSize_(blockSize), poolSize_(poolSize), pool_(nullptr), freeList_(nullptr)
{
allocatePool();
}
~FixedSizePool() {
std::free(pool_);
}
void* allocate() {
if (!freeList_) return nullptr; // pool exhausted
void* node = freeList_;
freeList_ = reinterpret_cast<void**>(freeList_[0]); // next free block
return node;
}
void deallocate(void* ptr) {
if (!ptr) return;
// Put back into free list
reinterpret_cast<void**>(ptr)[0] = freeList_;
freeList_ = reinterpret_cast<void**>(ptr);
}
private:
void allocatePool() {
pool_ = std::malloc(blockSize_ * poolSize_);
assert(pool_ && "Memory pool allocation failed");
// Initialize free list
freeList_ = reinterpret_cast<void**>(pool_);
for (std::size_t i = 0; i < poolSize_ - 1; ++i) {
reinterpret_cast<void**>(reinterpret_cast<std::byte*>(pool_) + i * blockSize_)[0] =
reinterpret_cast<void**>(reinterpret_cast<std::byte*>(pool_) + (i + 1) * blockSize_);
}
reinterpret_cast<void**>(reinterpret_cast<std::byte*>(pool_) + (poolSize_ - 1) * blockSize_)[0] = nullptr;
}
std::size_t blockSize_;
std::size_t poolSize_;
void* pool_;
void** freeList_;
};关键点说明
- 块大小：
blockSize_必须至少能容纳一个void*，否则链表无法存储下一个指针。 - 自由链表：每个空闲块的前
sizeof(void*)字节存储下一个空闲块的指针。 - 安全性：没有边界检查，假设使用者只在池内分配/释放。
3. 多线程安全版本
在多线程环境中，单纯的链表插入/删除需要加锁。下面使用 std::mutex 保护整个 allocate/deallocate 操作。若性能要求极高，可以采用无锁实现。
#include <mutex>
class ThreadSafeFixedSizePool {
public:
ThreadSafeFixedSizePool(std::size_t blockSize, std::size_t poolSize)
: pool_(blockSize, poolSize) {}
void* allocate() {
std::lock_guard<std::mutex> lock(mtx_);
return pool_.allocate();
}
void deallocate(void* ptr) {
std::lock_guard<std::mutex> lock(mtx_);
pool_.deallocate(ptr);
}
private:
FixedSizePool pool_;
std::mutex mtx_;
};4. 可变大小内存池（分段池）
若需要分配不同大小的对象，可以采用 分段池（Segmented Pool）方案。为每个大小区间创建一个固定大小池，例如 16、32、64、128、256 字节等。分配时选择合适的池。
class SegmentedPool {
public:
SegmentedPool() {
// 初始化若干大小段
pools_.emplace_back(16, 1024);
pools_.emplace_back(32, 1024);
pools_.emplace_back(64, 1024);
pools_.emplace_back(128, 1024);
pools_.emplace_back(256, 1024);
}
void* allocate(std::size_t size) {
for (auto& p : pools_) {
if (size <= p.blockSize_) return p.allocate();
}
// fallback to global new
return ::operator new(size);
}
void deallocate(void* ptr, std::size_t size) {
for (auto& p : pools_) {
if (size <= p.blockSize_) {
p.deallocate(ptr);
return;
}
}
::operator delete(ptr);
}
private:
std::vector <FixedSizePool> pools_;
};5. 何时使用内存池？
- 对象数量巨大且频繁创建/销毁：例如网络服务器的请求对象、游戏实体等。
- 性能敏感的实时系统：避免 GC/抖动。
- 内存碎片严重：需要统一对象大小时。
- 内存可控：可以预估需要的内存量，限制峰值占用。
6. 小结
内存池是 C++ 开发中提升分配性能与控制内存碎片的重要工具。本文从固定大小、线程安全到分段池等多角度提供了可直接使用的实现。根据实际需求选择合适的池策略，并注意线程安全与边界检查，可在许多高性能项目中大幅提升资源利用率。