C++ std::aligned_storage实现内存对齐的对象池

在C++中，频繁的内存分配和释放操作会带来性能开销。对象池是一种设计模式，它通过预先分配一大块内存，并在需要时从池中获取对象，用完后归还，从而避免频繁的动态内存分配。std::aligned_storage 是C++标准库提供的一个工具，可以创建一个原始的、满足特定对齐要求的内存块，不调用构造函数，非常适合用于实现对象池。

为什么需要对象池和内存对齐?

• 性能: 频繁的 new 和 delete 操作涉及系统调用，开销较大。对象池通过复用内存，显著减少了这些开销。
• 内存碎片: 频繁分配和释放可能导致内存碎片，影响程序性能和稳定性。对象池可以集中管理内存，减少碎片。
• 内存对齐: 现代CPU对数据在内存中的对齐方式有严格要求。未对齐的内存访问会导致性能下降，甚至程序崩溃。std::aligned_storage 确保我们分配的内存满足对象的对齐要求。

核心工具: std::aligned_storage

std::aligned_storage 是一个模板，它接受两个模板参数：对象的大小和对象的对齐要求。它提供了一个类型 type，这个类型是一个原始的、未初始化的内存块，其大小和对齐方式满足要求。

#include <type_traits>

// 定义一个类型，它是一个足够大的、对齐的原始内存块
using MyStorage = std::aligned_storage<sizeof(MyClass), alignof(MyClass)>::type;

实现步骤

我们将创建一个模板类 ObjectPool，用于管理特定类型 T 的对象。

1. 定义对象池类模板

首先，定义一个模板类 ObjectPool，它将管理类型为 T 的对象。

template <typename T>
class ObjectPool {
public:
    // ... 成员函数将在这里定义
private:
    // ... 成员变量将在这里定义
};

2. 设计内部数据结构

对象池需要两个核心数据结构：

• 一个 std::vector 来存储原始内存块。
• 一个 std::stack 来管理空闲内存块的索引。

此外，为了安全地管理对象的生命周期，我们需要一个机制来跟踪哪些内存块当前被使用，哪些是空闲的。这里我们使用一个 std::vector<bool> 来标记。

private:
    std::vector<std::aligned_storage<sizeof(T), alignof(T)>::type> storage_;
    std::vector<bool> used_; // 标记哪些内存块被使用了
    std::stack<size_t> freeIndices_; // 存储空闲内存块的索引

3. 实现构造函数 (预分配内存)

构造函数负责初始化对象池，预分配一定数量的内存块，并将它们的索引放入空闲栈中。

public:
    explicit ObjectPool(size_t initialSize = 10) {
        expandStorage(initialSize);
    }

private:
    void expandStorage(size_t newSize) {
        size_t currentSize = storage_.size();
        storage_.resize(newSize);
        used_.resize(newSize, false); // 新增的内存块默认为未使用

        // 将新分配的内存块索引压入空闲栈
        for (size_t i = currentSize; i < newSize; ++i) {
            freeIndices_.push(i);
        }
    }

4. 实现 acquire 方法 (获取对象)

acquire 方法从对象池中获取一个对象。如果池中没有空闲对象，它会自动扩容。

public:
    T* acquireRaw() {
        if (freeIndices_.empty()) {
            // 如果没有空闲对象，扩容池
            expandStorage(freeIndices_.size() + 1);
        }

        // 从空闲栈中获取一个索引
        size_t index = freeIndices_.top();
        freeIndices_.pop();

        // 在获取的内存块上构造对象
        T* objPtr = reinterpret_cast<T*>(&storage_[index]);
        new (objPtr) T(); // placement new

        // 标记该内存块为已使用
        used_[index] = true;

        return objPtr;
    }

5. 实现 release 方法 (回收对象)

release 方法将对象归还到池中。它首先调用对象的析构函数，然后将内存块标记为空闲。

public:
    void release(T* objPtr) {
        // 计算对象在 storage_ 中的索引
        size_t index = objPtr - &storage_[0];

        if (used_[index]) {
            // 显式调用析构函数
            objPtr->~T();

            // 标记为未使用，并加入空闲栈
            used_[index] = false;
            freeIndices_.push(index);
        }
    }

6. 实现析构函数 (清理内存)

析构函数负责清理对象池，确保所有已构造的对象都被正确析构。

public:
    ~ObjectPool() {
        // 析构所有正在使用的对象
        for (size_t i = 0; i < storage_.size(); ++i) {
            if (used_[i]) {
                reinterpret_cast<T*>(&storage_[i])->~T();
            }
        }

        // 清空数据结构
        storage_.clear();
        used_.clear();
        while (!freeIndices_.empty()) {
            freeIndices_.pop();
        }
    }

7. 使用 RAII 包装类 (安全使用)

直接返回裸指针容易导致内存泄漏或双重释放。一个更好的方法是使用 RAII（Resource Acquisition Is Initialization）原则，创建一个包装类 PoolObject。当 PoolObject 被销毁时，它会自动将对象归还到池中。

template <typename T>
class PoolObject {
public:
    PoolObject(ObjectPool<T>& pool, T* ptr) : pool_(pool), ptr_(ptr) {}

    // 当 PoolObject 被销毁时，自动释放对象
    ~PoolObject() {
        if (ptr_) {
            pool_.release(ptr_);
        }
    }

    // 重载 -> 和 * 运算符，使其像普通指针一样使用
    T* operator->() { return ptr_; }
    T& operator*() { return *ptr_; }

    // 禁用拷贝，防止意外拷贝导致双重释放
    PoolObject(const PoolObject&) = delete;
    PoolObject& operator=(const PoolObject&) = delete;

    // 允许移动，以便可以转移所有权
    PoolObject(PoolObject&& other) noexcept : pool_(other.pool_), ptr_(other.ptr_) {
        other.ptr_ = nullptr;
    }
    PoolObject& operator=(PoolObject&& other) noexcept {
        if (this != &other) {
            if (ptr_) {
                pool_.release(ptr_);
            }
            pool_ = other.pool_;
            ptr_ = other.ptr_;
            other.ptr_ = nullptr;
        }
        return *this;
    }

private:
    ObjectPool<T>& pool_;
    T* ptr_;
};

现在，我们可以修改 ObjectPool 的 acquire 方法，使其返回 PoolObject 而不是裸指针。

public:
    PoolObject<T> acquire() {
        if (freeIndices_.empty()) {
            expandStorage(freeIndices_.size() + 1);
        }
        size_t index = freeIndices_.top();
        freeIndices_.pop();
        T* objPtr = reinterpret_cast<T*>(&storage_[index]);
        new (objPtr) T();
        used_[index] = true;
        return PoolObject<T>(*this, objPtr);
    }

完整代码示例

将以上所有部分整合，得到一个完整的、可编译的对象池实现。

#include <iostream>
#include <vector>
#include <stack>
#include <memory>
#include <type_traits>
#include <new> // for placement new

// RAII 包装类，用于安全地使用对象池中的对象
template <typename T>
class PoolObject {
public:
    PoolObject(ObjectPool<T>& pool, T* ptr) : pool_(pool), ptr_(ptr) {}

    ~PoolObject() {
        if (ptr_) {
            pool_.release(ptr_);
        }
    }

    T* operator->() { return ptr_; }
    T& operator*() { return *ptr_; }

    PoolObject(const PoolObject&) = delete;
    PoolObject& operator=(const PoolObject&) = delete;

    PoolObject(PoolObject&& other) noexcept : pool_(other.pool_), ptr_(other.ptr_) {
        other.ptr_ = nullptr;
    }
    PoolObject& operator=(PoolObject&& other) noexcept {
        if (this != &other) {
            if (ptr_) {
                pool_.release(ptr_);
            }
            pool_ = other.pool_;
            ptr_ = other.ptr_;
            other.ptr_ = nullptr;
        }
        return *this;
    }

private:
    ObjectPool<T>& pool_;
    T* ptr_;
};

// 对象池类
template <typename T>
class ObjectPool {
public:
    explicit ObjectPool(size_t initialSize = 10) {
        expandStorage(initialSize);
    }

    PoolObject<T> acquire() {
        if (freeIndices_.empty()) {
            expandStorage(freeIndices_.size() + 1);
        }
        size_t index = freeIndices_.top();
        freeIndices_.pop();
        T* objPtr = reinterpret_cast<T*>(&storage_[index]);
        new (objPtr) T();
        used_[index] = true;
        return PoolObject<T>(*this, objPtr);
    }

    void release(T* objPtr) {
        size_t index = objPtr - &storage_[0];
        if (used_[index]) {
            objPtr->~T();
            used_[index] = false;
            freeIndices_.push(index);
        }
    }

    ~ObjectPool() {
        for (size_t i = 0; i < storage_.size(); ++i) {
            if (used_[i]) {
                reinterpret_cast<T*>(&storage_[i])->~T();
            }
        }
        storage_.clear();
        used_.clear();
        while (!freeIndices_.empty()) {
            freeIndices_.pop();
        }
    }

private:
    void expandStorage(size_t newSize) {
        size_t currentSize = storage_.size();
        storage_.resize(newSize);
        used_.resize(newSize, false);

        for (size_t i = currentSize; i < newSize; ++i) {
            freeIndices_.push(i);
        }
    }

    std::vector<std::aligned_storage<sizeof(T), alignof(T)>::type> storage_;
    std::vector<bool> used_;
    std::stack<size_t> freeIndices_;
};

如何使用对象池

下面是一个使用 ObjectPool 的示例，管理 int 类型的对象。

int main() {
    // 创建一个可以存储10个int的对象池
    ObjectPool<int> intPool(10);

    {
        // 从池中获取一个int对象
        auto intObj1 = intPool.acquire();
        *intObj1 = 42;
        std::cout << "Value: " << *intObj1 << std::endl; // 输出: Value: 42

        // 再获取一个
        auto intObj2 = intPool.acquire();
        *intObj2 = 100;
        std::cout << "Value: " << *intObj2 << std::endl; // 输出: Value: 100

        // intObj1 和 intObj2 在作用域结束时自动释放
    }

    {
        // 再次获取，应该会复用之前释放的内存
        auto intObj3 = intPool.acquire();
        std::cout << "Value: " << *intObj3 << std::endl; // 输出可能是随机的，因为之前释放时没有清零
        *intObj3 = 200;
    }

    return 0;
}

注意事项与优化

• 线程安全: 当前的 ObjectPool 实现不是线程安全的。如果在多线程环境中使用，需要对 acquire 和 release 方法进行加锁。
• 扩容策略: 示例中的扩容策略是简单的。可以根据实际需求采用更复杂的策略，如指数增长。
• 内存泄漏: PoolObject 禁用了拷贝，防止了意外的内存泄漏。但要注意，不要保存 PoolObject 内部指针的副本，这会导致双重释放。
• 性能: 对于没有默认构造函数的类，new (objPtr) T() 可能需要参数。可以扩展 acquire 方法，接受构造参数。