C++中的内存池：实现高效内存分配

作者

在现代高性能应用中，频繁的内存分配与释放往往成为瓶颈。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_;
};

关键点说明

  1. 块大小：blockSize_ 必须至少能容纳一个 void*，否则链表无法存储下一个指针。
  2. 自由链表：每个空闲块的前 sizeof(void*) 字节存储下一个空闲块的指针。
  3. 安全性：没有边界检查，假设使用者只在池内分配/释放。

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++ 开发中提升分配性能与控制内存碎片的重要工具。本文从固定大小、线程安全到分段池等多角度提供了可直接使用的实现。根据实际需求选择合适的池策略，并注意线程安全与边界检查，可在许多高性能项目中大幅提升资源利用率。

发表评论