C++ std::shared_ptr自定义allocator引入内存池

当C++项目里做了大量的动态内存分配与释放，可能会导致内存碎片，使系统性能降低。当动态内存分配的开销变得不容忽视时，一种解决办法是一次从操作系统分配一块大的静态内存作为内存池进行手动管理，堆对象内存分配时从内存池中分配一块类对象大小的内存，释放时并不实际将内存归还给操作系统，而是交给自定义的内存管理模块处理。本文介绍基于std::shared_ptr自定义allocator引入内存池的方法。

尝试重写new和delete运算符

项目中大量使用std::shared_ptr且与多个模块耦合，如果直接将 std::shared_ptr 重构为手动管理裸指针的实现，改动量太大，而且可能会带来不可预料的问题。于是尝试了重写new和delete运算符并添加了打印，发现 std::shared_ptr 的创建并不会直接调用 new和 delete，原因在于std::shared_ptr 有自己的内存分配机制。

std::allocate_shared

于是，想到了STL的一大组件 Allocator。C++提供了 std::alloc_shared 函数，可以自定义std::shared_ptr 的内存分配方式，其定义如下：

std::allocate_shared<T>(custom_alloc, std::forward<Args>(args)...);

仅需传入自定义分配器allocator和T的构造参数列表。

实际上， std::make_shared 就是对以上函数进行了封装，使用了默认的分配器。

MemoryPool的使用

内存池直接采用了相关开源项目的定义：

可以选用

https://github.com/DevShiftTeam/AppShift-MemoryPool

或

Fast Efficient Fixed-Sized Memory Pool

MemoryPoolManager 管理内存池的类

分配内存池

内存池需要拥有静态生命周期，因此将内存池管理类 MemoryPoolManager 设计为全局单例模式实现，定义Alloc() 和 Free() 方法，实现了内存池与自定义分配器解耦。

引入自旋锁实现线程安全

由于使用的相关开源内存池不是线程安全的，因此引入了自旋锁在内存池做内存分配和释放时加锁。自旋锁采用了以下文章中的实现：

Correctly implementing a spinlock in C++

MemoryPoolManager 的完整实现如下：



class MemoryPoolManager {

public:

	static MemoryPoolManager& GetInstance();

	void* Alloc(size_t sz);

	void Free(void* p);

	~MemoryPoolManager();

private:

	MemoryPoolManager();

	MemoryPoolManager(const MemoryPoolManager&)=delete;

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

  MemoryPool* pool_;

	SpinLock spin_lock_;

};

MemoryPoolManager& MemoryPoolManager::GetInstance() {

		static MemoryPoolManager instance;

    return instance;

}

MemoryPoolManager::MemoryPoolManager() {

    pool_ = new MemoryPool();

}

MemoryPoolManager::~MemoryPoolManager() {

    std::lock_guard<SpinLock> lock(spin_lock_);

    delete pool_;

}

void* MemoryPoolManager::Alloc(size_t sz) {

    std::lock_guard<SpinLock> lock(spin_lock_);

    return pool_->allocate(sz);

}

void MemoryPoolManager::Free(void* p) {

    std::lock_guard<SpinLock> lock(spin_lock_);

    pool_->free(p);

}

自定义分配器Custom Allocator

为了使用 std::alloc_shared ，还需要实现 Custom Allocator 。其中包含了需要的函数和别名定义，相关文章可参考： Building Your Own Allocators。以下接口中许多成员在C++20中被移除。

template <typename T>

class CustomAllocator {

public:

    using value_type = T;

    using size_type = std::size_t;

    using difference_type = std::ptrdiff_t;

    CustomAllocator() = default;

    ~CustomAllocator() = default;

    template <typename U>

    CustomAllocator(const CustomAllocator<U>&) noexcept {}

    T* allocate(size_t n) {

        return static_cast<T*>(MemoryPoolManager::GetInstance().Alloc(n * sizeof(T)));

    }

    void deallocate(T* p, size_t) {

        MemoryPoolManager::GetInstance().Free(p);

    }

    size_type max_size() const noexcept {

        return std::numeric_limits<size_type>::max() / sizeof(T);

    }

private:

    template <typename U>

    friend class CustomAllocator;

};

其中T* allocate(size_t n)方法实现内存的分配，直接调用了MemoryPoolManager的 Alloc方法；void deallocate(T* p, size_t) 做内存的释放，直接调用了MemoryPoolManager的 Free 方法。

我们知道 new操作会分配内存并会调用类的构造函数，那么allocate 了需要手动调用构造函数吗？

在自定义分配器中，一般不需要手动实现 construct 和 destroy，因为标准库中的 std::allocator_traits 会处理这些工作。std::allocator_traits 默认会使用 placement new 来调用对象的构造函数，并调用对象的析构函数。

相当于在CustomAllocator 中增加以下函数：

template<typename U, typename... Args>

void construct(U* p, Args&&... args) {

  ::new((void*)p) U(std::forward<Args>(args)...);

}

template<typename U>

void destroy(U* p) {

  p->~U();

}

使用`std::allocate_shared`

接下来就可以使用std::allocate_shared了，需传入自定义分配器allocator对象和类的构造函数参数列表。仿照 std::make_shared的实现，基于可变长参数模板做了一层函数封装：

template <typename T, typename... Args>

std::shared_ptr<T> AllocateShared(Args&&... args) {

    return std::allocate_shared<T>(CustomAllocator<T>(), std::forward<Args>(args)...);

}

这样，使用AllocateShared 直接就可以返回一个std::shared_ptr