池化技术-版本二

版本1的问题

1）对象池中的对象没有到达上限，无法增加对象。

2）丢失的对象会造成内存泄漏。

3) 不知道借出对象的个数和空闲对象的个数；

版本2：

设计：

        对象池类型中设计两个队列， 一个是空闲队列，一个是活动队列；

        设计一个私有方法AddObject();

#define LOG(info) \
    cout << __FILE__ << ":" << __LINE__ << " " \
    << __TIMESTAMP__ << " : " << info << endl;
const int MaxObjectNum = 10;
template<class T>
class ObjectPool
{
private:
    bool needClose; // 需要关闭的标记
    std::deque<T*> m_active_object_queue; // 活动队列，借出对象存储的队列
    std::deque<T*> m_idle_object_queue; // 空闲队列
    往对象池中新增一个对象
    void AddObject()
    {
        m_idle_object_queue.push_back(new T());
    }
public:
    ObjectPool() :needClose(false) {}
    ObjectPool(const ObjectPool&) = delete;
    ObjectPool& operator=(const ObjectPool&) = delete;
    ~ObjectPool()
    {
        Close();
    }
    //关闭对象池
    void Close()
    {
        needClose = true;
        Clear();
    }
    //清空对象池中闲置的所有对象
    void Clear()
    {
        for (auto x : m_idle_object_queue)
        {
            delete x;
        }
    }
    //获取当前闲置在对象池中的对象数量，即没有被拿走使用的对象数量
    size_t GetNumIdle() const
    {
        return m_idle_object_queue.size();
    }
    //获取已经在使用中的对象数量，即被使用者从对象池中拿走使用的数量
    size_t GetNumActive() const
    {
        return m_active_object_queue.size();
    }
    void Init(size_t num)
    {
        if (needClose)
        {
            LOG("对象池已关闭");
            exit(1);
        }
        if (num <= 0 || num > MaxObjectNum)
        {
            LOG("创建对象个数错误");
            exit(1);
        }
        for (size_t i = 0; i < num; ++i)
            {
            // 添加对象
            m_idle_object_queue.push_back(new T());
        }
    }
public:
    //从对象池中获取对象的方法
    T* borrowObject() //借对象
    {
        if (m_idle_object_queue.empty())
        {
            LOG("空闲队列已空无对象可借");
            if (m_active_object_queue.size() >= MaxObjectNum)
            {
                LOG("对象池中对象的个数已到达上限");
                return nullptr;
            }
            AddObject();
            LOG("增加对象成功");
        }
        // 将队列中的对象借出
        T* tmp = m_idle_object_queue.front();
        m_idle_object_queue.pop_front();
        m_active_object_queue.push_back(tmp);
        return tmp;
    }
    //将对象返还给对象池
    void returnObject(T* p)
    {
        if (nullptr == p)
        {
            LOG("借出对象丢失或提供了nullptr 指针");
            return;
        }
        m_idle_object_queue.push_back(p);
        if (std::erase(m_active_object_queue, p))
        {
            LOG("对象已经归还");
        }
        else
        {
            LOG("不是对象池中对象");
            exit(1);
        }
    }
};
// 测试
int main()
{
    ObjectPool<Point> objpool;
    objpool.Init(2);
    Point* p1 = objpool.borrowObject();
    Point* p2 = objpool.borrowObject();
    Point* p3 = objpool.borrowObject();
    Point* p4 = objpool.borrowObject();
    Point* p5 = objpool.borrowObject();
    //
    objpool.returnObject(p1);
    objpool.returnObject(p2);
    objpool.returnObject(p3);
    objpool.returnObject(p4);
    objpool.returnObject(p5);
    return 0;
}