C++定长内存池原理与高性能实现

1. 为什么需要定长内存池？

在C++开发中，内存分配是一个永恒的话题。每当我们使用new或malloc时，操作系统都需要在堆内存中寻找合适大小的空闲块。这个过程看似简单，但在高并发场景下却可能成为性能瓶颈。

想象一下餐厅点餐的场景：传统内存分配就像每次点菜都要现做（频繁调用new），而定长内存池则像是提前备好的套餐（预分配固定大小内存块）。当100个客人同时点同一份套餐时，备餐速度自然快得多。

实测数据：在单线程环境下，定长内存池的分配速度比常规new快5-8倍；多线程环境下差距可达20倍以上

2. 定长内存池的实现原理

2.1 核心数据结构设计

一个典型的定长内存池包含三个关键组件：

1. 内存块链表（自由链表）：维护可用内存块的指针集合
2. 分配器（Allocator）：处理内存请求的接口
3. 回收器（Deallocator）：管理内存释放的逻辑

cpp复制struct MemoryBlock {
    MemoryBlock* next;
    char data[BLOCK_SIZE - sizeof(MemoryBlock*)];
};

2.2 内存分配流程

1. 初始化时预分配大块内存（如1MB）
2. 将大内存分割为等大小的小块（如64字节/块）
3. 用链表串联所有小块形成自由链表
4. 分配时直接从链表头部取节点
5. 释放时将节点插回链表头部

cpp复制void* allocate() {
    if (!freeList) {
        expandPool();
    }
    MemoryBlock* block = freeList;
    freeList = freeList->next;
    return block->data;
}

3. 实战：手写高性能内存池

3.1 基础版本实现

cpp复制class FixedMemoryPool {
public:
    FixedMemoryPool(size_t blockSize, size_t blockCount) 
        : blockSize_(blockSize), blockCount_(blockCount) {
        initialize();
    }
    
    void* allocate() {
        if (!freeList_) expand();
        MemoryBlock* block = freeList_;
        freeList_ = freeList_->next;
        return static_cast<void*>(block);
    }
    
    void deallocate(void* ptr) {
        MemoryBlock* block = static_cast<MemoryBlock*>(ptr);
        block->next = freeList_;
        freeList_ = block;
    }

private:
    void initialize() {
        chunk_ = ::malloc(blockSize_ * blockCount_);
        freeList_ = static_cast<MemoryBlock*>(chunk_);
        
        MemoryBlock* current = freeList_;
        for (size_t i = 0; i < blockCount_ - 1; ++i) {
            current->next = reinterpret_cast<MemoryBlock*>(
                reinterpret_cast<char*>(current) + blockSize_);
            current = current->next;
        }
        current->next = nullptr;
    }
    
    void expand() {
        // 扩展逻辑类似initialize
    }
    
    size_t blockSize_;
    size_t blockCount_;
    void* chunk_;
    MemoryBlock* freeList_;
};

3.2 线程安全优化

基础版本在多线程环境下会出现竞态条件。我们可以通过以下方式增强线程安全：

1. 互斥锁方案（简单但性能一般）：

cpp复制std::mutex mtx_;

void* allocate() {
    std::lock_guard<