C++ 对象池

对象池

概念

对象池模式（Object Pool Pattern），是创建型设计模式的一种，将对象预先创建并初始化后放入对象池中，对象提供者就能利用已有的对象来处理请求，减少频繁创建对象所占用的内存空间和初始化时间。

对象池的用户可以从池子中取得对象，对其进行操作处理，并在不需要时归还给池子而非直接销毁。对象池是一个特殊的工厂对象，对象池模式就是单例模式加享元模式。

享元模式（Flyweight Pattern）是一种结构型设计模式，它用于减少创建对象的数量，从而降低内存的使用。享元模式通过共享尽可能多的相似对象来实现这一点。

适用场景

对象池模式主要适用于以下应用场景。

资源受限的场景。比如，不需要可伸缩性的环境（CPU\内存等物理资源有限），CPU性能不够强劲，内存比较紧张，垃圾收集，内存抖动会造成比较大的影响，需要提高内存管理效率，响应性比吞吐量更为重要。
在内存中数量受限的对象。
创建成本高的对象，可以考虑池化。
在需要快速响应的系统中，对象池可以减少等待对象创建的时间，从而提高系统的响应性。

常见的使用对象池的场景有在使用Socket时的各种连接池、线程池、数据库连接池等。
线程池也算特殊的对象池

实现方式

对象池的使用：

从对象池中获取对象，如果没有对象，则创建一个，并返回
使用对象
使用完成对象后，将对象还回对象池

实现对象池时注意的点：

对象的自动回收
线程安全
对象池重复利用时进行reset，保持对象的一致性

对象池的实现：

实现使用shared_ptr或者unique_ptr。
实现采取new和delete，需要自己去检查什么对象需要回收

无法直接将shared_ptr的删除器修改为自定义删除器，所以在使用shared_ptr时，需要一开始就定义回收函数，并把创建都委托给对象池
使用unique_ptr时，可以很方便的修改删除器

缺点和可以优化的点

对象池的缺点：

对象池在使用的时候，如果不加以控制，那么会增加内存消耗
比如仅在某个时间段突然需要大量对象，其他时间只用少量对象
此时对象池不够，需要添加更多的对象。而当增加完对象后，大量对象长时间存在内存里没有被使用，就导致了内存消耗。

未来优化：

可以在对象池初始化时传入工厂对象，用工厂来进行创建，而不是简单的new

示例代码

代码中需要注意使用对象池时，需要对象创建时没有入参，必须实现清理函数cleanup，以保证放入对象池中对象是干净可以复用的。
包含测试代码

#include <iostream>
#include <vector>
#include <functional>
#include <mutex>
#include <memory>
#include <atomic>
#include <thread>

template <typename T, typename = void>
struct has_cleanup : std::false_type {};

template <typename T>
struct has_cleanup<T, std::void_t<decltype(std::declval<T>().cleanup())>> : std::true_type {};

// 对象池
// 可以结合单例模式使用
template<typename T>
class ObjectPool
{
private:
    int maxsize_;
    int minsize_;
    int count_;
    std::mutex mutex_;
    std::vector<std::shared_ptr<T>> obj_list_;
    std::function<void(T* obj_ptr)> obj_destroy_func_;
    std::atomic_bool is_destructed_;
    
public:
    ObjectPool(int minSize, int maxSize)
    {
        static_assert(has_cleanup<T>::value, "T must have a cleanup() function");
        maxsize_ = maxSize;
        minsize_ = minSize;
        obj_list_.reserve(maxSize);

        obj_destroy_func_ = [&](T* obj_ptr)
        {
            if(is_destructed_ == true)
            {
                obj_ptr->cleanup();
                delete obj_ptr;
            }
            else
            {
                // 加入回收池
                obj_ptr->cleanup();
                std::lock_guard<std::mutex> lock(mutex_);
                obj_list_.push_back(std::shared_ptr<T>(obj_ptr, obj_destroy_func_));
            }
        }; 
        for(int i = 0; i < minsize_; i++)
        {
            obj_list_.emplace_back(new T(), obj_destroy_func_);
        }
        count_ = minsize_;
    }
    ~ObjectPool()
    {
        is_destructed_ = true;
    }
    
    std::shared_ptr<T> GetObject()
    {
        std::shared_ptr<T> result;
        std::lock_guard<std::mutex> lock(mutex_);
        if(obj_list_.empty())
        {
            if(count_ < maxsize_)
            {
                count_++;
                result = std::shared_ptr<T>(new T(), obj_destroy_func_);
            }
            else
            {
                // throw std::runtime_error("ObjectPool is full");
                std::cout << "ObjectPool is full" << std::endl;
                return nullptr;
            }
        }
        else
        {
            result = obj_list_.back();
            obj_list_.pop_back();
        }
        return result;
    }
};


class test
{
public:
    test(): num_{999} {}
    void init(int num)
    {
        num_ = num;
    }
    int num_;
    void cleanup()
    {
        std::cout << "cleanup: " << num_ << std::endl;
    }
};

int main()
{
    
    {
        ObjectPool<test> pool(5, 10);
        for(int i = 0; i < 3; i++)
        {
            std::shared_ptr<test> obj_ptr = pool.GetObject();
            if(obj_ptr != nullptr)
            {
                obj_ptr->init(i);
            }
            else
            {
                std::cout << "GetObject failed" << std::endl;
            }
        }
    }
    
    
    // std::this_thread::sleep_for(std::chrono::seconds(10));
    std::cout << "------------------------------------" << std::endl;
    return 0;
}