基于c++实现的对象池(简单测试)

代码如下（结尾有示例）:

#pragma once
#include <iostream>
#include <mutex>
#include <deque>
template<typename OBJ_TYPE>
struct Object{
    using Mtx             = std::mutex;
    using SimpLock        = std::lock_guard<Mtx>;
    using OBJ_PTYPE       = std::shared_ptr<OBJ_TYPE>;
    using QueueType       = std::deque<OBJ_PTYPE>;
    using OBJQueue        = std::shared_ptr<QueueType>;
};

template<typename OBJ_TYPE>
class ObjCont;

//池类
template<typename OBJ_TYPE>
class ObjPool:public Object<OBJ_TYPE>
{
friend class ObjCont<OBJ_TYPE>;
public:
    ObjPool()
    {
        mtx_=std::make_shared<std::mutex>();
        que_obj_=std::make_shared<QueueType>();
    }

    ObjPool(const ObjPool<OBJ_TYPE>& oth)
    {
        mtx_=oth.mtx_;
        SimpLock lock (*mtx_);
        que_obj_ = oth.que_obj_;
    }

    void pushObj(const OBJ_PTYPE& obj)
    {
        SimpLock lock (*mtx_);
        que_obj_->push_back (std::move (obj));
    }

    size_t getObjSize ()
    {
        SimpLock lock (*mtx_);
        return que_obj_->size ();
    }

private:
    OBJ_PTYPE __takeOjb()
    {
        SimpLock lock (*mtx_);
        if(que_obj_->empty())
            return std::make_shared<OBJ_TYPE> ();
        auto obj=que_obj_->front();
        que_obj_->pop_front();
        return obj;
    }

    template<typename... OBJ_ARGS>
    OBJ_PTYPE __takeOjb (const OBJ_ARGS&... args)
    {
        return std::make_shared<OBJ_TYPE>(args...);
    }
   
private:
    std::shared_ptr<std::mutex>  mtx_;
    OBJQueue              que_obj_;

};

//容器类
template<typename OBJ_TYPE>
class ObjCont:public Object<OBJ_TYPE>
{
public:
    ObjCont (const ObjPool<OBJ_TYPE>& pool):pool_(pool),obj_(std::move(pool_.__takeOjb()))
    {
    }

    template<typename... OBJ_ARGS>
    ObjCont (const ObjPool<OBJ_TYPE>& pool, const OBJ_ARGS&... args) :pool_ (pool),obj_(std::move(pool_.__takeOjb(args...)))
    {
    }

    ~ObjCont ()
    {
        pool_.pushObj(obj_);
    }
    
    inline std::shared_ptr<OBJ_TYPE>& refObj () 
    {
        return obj_;
    }

private:
    ObjPool<OBJ_TYPE>     pool_;
    OBJ_PTYPE              obj_;

};

示例如下:

#include <iostream>
#include <mutex>
#include <thread>
#include "ObjectPool.hpp"


struct  OBJ
{
    OBJ ()
    {
    }

    OBJ (const std::string& data) :data_ (data)
    {
    }

    ~OBJ ()
    {
    }

    std::string data_;
};


int main ()
{
    //定义一个池
    ObjPool<OBJ> pool;
    {
        //产生一个对象 并随便给个值
        ObjCont<OBJ> cont (pool);
        cont.refObj ()->data_ = std::string ("1111");

        
    }//析构ObjCont 自动把OBJ放入池中

    std::thread ([&]()
        {
            //从池里面取出一个对象 这个对象应该是上面赋值的对象 值为“1111”;
            ObjCont<OBJ> cont (pool);
            std::cout <<cont.refObj ()->data_ << std::endl;
            std::this_thread::sleep_for (std::chrono::seconds (550));
        }).detach ();

        //再次生产一个对象 此次池中无对象 这个对象值应该为空 
        {
            std::this_thread::sleep_for (std::chrono::seconds (3));
            ObjCont<OBJ> cont (pool);
            std::cout << "thread id:" << std::this_thread::get_id () << "," << cont.refObj ()->data_ << std::endl;
        }
        getchar ();
        return 0;
}