C++对象池以及shared_ptr的支持 - HelloWorld开发者社区

对象池和支持对象池的shared_ptr
性能测试
数字的单位是微妙分配5万个 1kb的object
C++对象池以及shared_ptr的支持
10 kb
C++对象池以及shared_ptr的支持
100kb
C++对象池以及shared_ptr的支持
500b
C++对象池以及shared_ptr的支持
128b
C++对象池以及shared_ptr的支持
因此只考虑对象分配速度问题的话大于 512的对象推荐使用pool版本
C++对象池以及shared_ptr的支持
第一个是：自己实现的池容器对象池
第二个是：make_shared 非对象池
第三个是：原始的new delete 非对象池
测试2：
C++对象池以及shared_ptr的支持
和上上面的一样只不过第一条数据是 std::queue 而非自己实现的容器
对于release 0x3优化版本的测试相差很大
C++对象池以及shared_ptr的支持
32bytes
C++对象池以及shared_ptr的支持
64bytes
C++对象池以及shared_ptr的支持
128 bytes
C++对象池以及shared_ptr的支持
512
C++对象池以及shared_ptr的支持
10kb
C++对象池以及shared_ptr的支持
因此综合来看超过 32 字节的都应该用pool来处理
Object.h
#pragma  once
/*
Email me@dreamyouxi.com

注意事项：
1.使用例子在cpp文件各种test函数里面
2.

class说明：
RawObject：
1.最原始的指针 只不过封装了一个release函数 用于delete this

RefObject：
1.简单的引用计数 需要手动去计数 Retain Release快速简单

RefObjectThreadSafe：
1.RefObject的线程安全版本 只保证计数安全

SharedObject：
1.std::enable_shared_from_this 封装 无需手动在继承 如果想用原始的std::shared_ptr可以继承方便使用

Recycleable：
1.对象池可回收对象 ctor和dtor需要重写 以供初始化内部数据

share_ptr：
1.ShareObjectPool 专有的指针类型 内部封装了std::shared_ptr,必需配合ShareObjectPool 使用


对象池：
ObjectPool ：
1.64字节以上的class 都应该使用pool
2.对象池管理的对象必需是 RawObjectRecycleable OR RefObjectRecycleable OR Recycleable(需要手动调用ObjectPool::Release) 的子类
3.对于子类来说必需提供默认无参数构造函数public，对于构造方法请用其他方法(ctor or other member function)实现 而非依托于构造函数

ShareObjectPool：
1.64字节以上的class 都应该使用pool
2.该对象池相比ObjectPool 是share_ptr的专有对象池 利用share_ptr来管理对象的生命周期
3.管理的对象必需是 ShareObjectRecycleable 的子类
4.对于子类来说必需提供默认无参数构造函数public，对于构造方法请用其他方法(ctor or other member function)实现 而非依托于构造函数

TODO:
1.考虑是否不让new跑出异常而继续程序运行 new(std::nothrow)XX;
*/
#include <memory>
#include <atomic>
#include <mutex>

class Object
{
public:
};
//raw pointer object
class RawObject
{
public:
    /**
    * @brief  call this to delete object
    */
    inline    virtual     void Release()
    {
        delete this;
    }
    virtual    ~RawObject()
    {

    }
};
//reference counter object
//this class is none-thread-safe, thread-safe replacer is (std::shared_ptr) or RefObjectThreadSafe
class RefObject
{
protected:
    int referenct_count = 1;
public:
    /**
    * @brief add reference count
    */
    inline    void Retain()
    {
        ++referenct_count;
    }
    /**
    * @brief  reduce reference count
    */
    inline    virtual    void Release()
    {
        --referenct_count;
        if (referenct_count <= 0)
        {
            delete this;
        }
    }
    inline int GetReferenceCount()const
    {
        return referenct_count;
    }
    virtual    ~RefObject()
    {

    }
    //TODO add this to auto release pool or add std::shared_ptr suport

};
//reference counter object
class RefObjectThreadSafe
{
protected:
    std::atomic<int> referenct_count = 1;
public:
    /**
    * @brief add reference count
    */
    inline    void Retain()
    {
        ++referenct_count;
    }
    /**
    * @brief  reduce reference count
    */
    inline    virtual    void Release()
    {
        --referenct_count;
        if (referenct_count == 0)
        {
            delete this;
        }
    }
    inline int GetReferenceCount()const
    {
        return referenct_count;
    }
    virtual    ~RefObjectThreadSafe()
    {

    }
    //TODO add this to auto release pool or add std::shared_ptr suport

};

//raw  share ptr wrapper class 
//create by std::make_shared ,pass object by share_from_this or std::shared_ptr's method
template<typename SubClassType>
class SharedObject :public std::enable_shared_from_this<SubClassType>
{
public:
    virtual ~SharedObject()
    {

    }
    //xxx->share_from_this();
};

//for object pool 
class Recycleable
{
public:
    /**
    * @brief when re-use this class this will be call
    */
    virtual void ctor() = 0;
    /**
    * @brief when recycle by pool this will be call
    */
    virtual void dtor() = 0;
    //tag for class  ObjectPool
    //泛型约束
    inline void ___type_sub_class_restrain__FOR_ObjectPool()
    {
    }
};

class NoneRecycleable
{
public:
    void ctor() = delete;
    void dtor() = delete;
};

template< class T, bool ThreadSafe>
class share_ptr;

//对象>=该大小时才会使用Pool 否则Pool会动态new 和delete
#define OBJECT_POOL_MIN_SIZEOF 32
//40KB 1w objects
#define OBJECT_POOL_MAX_SIZE 10240
//1Kb  为对象池 预分配的 队列空间 的个数大小
#define OBJECT_POOL_DEFAULT_ALLOC_SIZE 512
//对象池预分配对象大小 必需小于 OBJECT_POOL_DEFAULT_ALLOC_SIZE
#define OBJECT_POOL_DEFAULT_ALLOC_OBJECT_SIZE 256

template< typename ClassType, typename bool ThreadSafe = false>
class ObjectPool
{
    template< class ClassType, bool ThreadSafe = false>
    class Ctor
    {
    public:
        Ctor()
        {//ctor
            int capacity = ObjectPool<ClassType, ThreadSafe>::capacity;
            auto pool = ObjectPool<ClassType, ThreadSafe>::_pool;
            for (int i = 0; i < capacity; i++)
            {
                pool[i] = nullptr;
            }
        }
        ~Ctor()
        {//dtor
            ObjectPool<ClassType, ThreadSafe>::Clear();
            //如果编译报错 那么证明不是约束下的 子类关系 请确认
            ClassType * s = nullptr;
            s->___type_sub_class_restrain__FOR_ObjectPool();
        }
    };
    ObjectPool();
    static int capacity;
    static ClassType** _pool;
    static int size;
    static std::mutex _mutex;
private:
    /**
    * @brief resize inner pool growing by twice
    * @warning this will copy old block and delete old
    */
    static void ReSize()
    {
        auto pool = new ClassType*[capacity * 2];//
        memset(pool, 0, sizeof(ClassType*)* 2 * capacity);
        memcpy(pool, _pool, sizeof(ClassType*)* capacity);
        capacity *= 2;
        delete _pool;
        _pool = pool;
    }
    static void PreAlloc()
    {
        auto pool = _pool;
        for (int i = 0; i < OBJECT_POOL_DEFAULT_ALLOC_OBJECT_SIZE; i++)
        {
            pool[size] = new ClassType();
            ++size;
        }
    }
public:
    /**
    * @brief  call this to new class who is the sub-class of Recycleable
    * @note if class size if smaller than OBJECT_POOL_MIN_SIZEOF will new otherwise will gen object from pool
    */
    static ClassType* Create()
    {
        if (ThreadSafe)
        {
            ClassType * ret = nullptr;
            {
                std::lock_guard<std::mutex> locker(_mutex);
                static ObjectPool<ClassType, ThreadSafe>::Ctor<ClassType, ThreadSafe> ctor;//c11 compiler suport thread-safe
                if (size > 0 && sizeof(ClassType) >= OBJECT_POOL_MIN_SIZEOF)
                {
                    --size;
                    ret = (_pool[size]);
                    _pool[size] = nullptr;
                }
            }
            if (!ret)
            {
                ret = new ClassType();
            }
            ret->ctor();
            return ret;
        }
        else
        {
            //ctor之所以弄为函数的static是因为全局的static析构并不完全和定义顺序一致 因为为了避免不同编译器下出错就放在这里了
            //局部的肯定比全局的先析构
            static ObjectPool<ClassType, ThreadSafe>::Ctor<ClassType, ThreadSafe> ctor;//c11 compiler suport thread-safe
            if (size > 0 && sizeof(ClassType) >= OBJECT_POOL_MIN_SIZEOF)
            {
                --size;
                ClassType* ret = (_pool[size]);
                _pool[size] = nullptr;
                ret->ctor();
                return ret;
            }
            auto ret = new ClassType();
            ret->ctor();
            return ret;
        }
    }
    /**
    * @brief release object to the pool
    * @note if sizeof class is smaller than OBJECT_POOL_MIN_SIZEOF will delete now otherwise will put into pool
    */
    static void Release(ClassType* who)
    {
        if (!who)return;
        who->dtor();
        if (sizeof(ClassType) < OBJECT_POOL_MIN_SIZEOF)
        {
            delete who;
            return;
        }
        if (ThreadSafe)
        {
            std::lock_guard<std::mutex> locker(_mutex);
            if (size >= OBJECT_POOL_MAX_SIZE)
            {
                cout << capacity << " " << typeid(ObjectPool<ClassType, ThreadSafe>).name() << " warnning Release out-of-size" << endl;
                delete who;
                return;
            }
            if (size >= capacity)
            {
                ReSize();
            }
            _pool[size] = who;
            ++size;
        }
        else
        {
            if (size >= OBJECT_POOL_MAX_SIZE)
            {
                cout << capacity << " " << typeid(ObjectPool<ClassType, ThreadSafe>).name() << " warnning Release out-of-size" << endl;
                delete who;
                return;
            }
            if (size >= capacity)
            {
                ReSize();
            }
            _pool[size] = who;
            ++size;
        }
    }
    /**
    * @brief  delete all objects in this pool
    */
    static void Clear()
    {
        if (ThreadSafe)
        {
            std::lock_guard<std::mutex> locker(_mutex);
            auto pool = _pool;
            auto _size = size;
            if (_size <= 0)return;
            for (int i = 0; i < _size; i++)
            {
                if (pool[i])
                {
                    delete pool[i];
                    pool[i] = nullptr;
                }
            }
            size = 0;
        }
        else
        {
            auto pool = _pool;
            auto _size = size;
            if (_size <= 0)return;
            for (int i = 0; i < _size; i++)
            {
                if (pool[i])
                {
                    delete pool[i];
                    pool[i] = nullptr;
                }
            }
            size = 0;
        }
    }
    inline static int Size()
    {
        if (ThreadSafe)
        {
            std::lock_guard<std::mutex> locker(_mutex);
            return  size
        }
        else
        {
            return  size;
        }
    }
    /**
    * @brief print current pool status for debug
    */
    static    void PrintStatus()
    {
        int total = (sizeof(ClassType)* size);
        if (total < 1024)
        {
            cout << "capacity:" << capacity << " size:" << size << " memeory:" << (sizeof(ClassType)* size) << "B " << typeid(ObjectPool<ClassType, ThreadSafe>).name() << endl;
        }
        else if (total < 1024 * 1024)
        {
            cout << "capacity:" << capacity << " size:" << size << " memeory:" << (sizeof(ClassType)* size) / 1024.0 << "KB " << typeid(ObjectPool<ClassType, ThreadSafe>).name() << endl;
        }
        else
        {
            cout << "capacity:" << capacity << " size:" << size << " memeory:" << (sizeof(ClassType)* size) / 1024.0 / 1024.0 << "MB " << typeid(ObjectPool<ClassType, ThreadSafe>).name() << endl;
        }
    }
};
template<class ClassType, bool ThreadSafe>
ClassType**ObjectPool<ClassType, ThreadSafe>::_pool = new ClassType*[OBJECT_POOL_DEFAULT_ALLOC_SIZE];//
template<class ClassType, bool ThreadSafe>
int ObjectPool<ClassType, ThreadSafe>::size = 0;
template<class ClassType, bool ThreadSafe>
std::mutex ObjectPool<ClassType, ThreadSafe>::_mutex;
template<class ClassType, bool ThreadSafe>
int ObjectPool<ClassType, ThreadSafe>::capacity = OBJECT_POOL_DEFAULT_ALLOC_SIZE;




//自带share_ptr版本 无需手动调用 Object::Release
//适用于 SharedObjectRecycleable的子类的对象池
//因为模板的模板 特化 不好处理 因此干脆重新开个名字 ShareObjectPool
template< typename ClassType, typename bool ThreadSafe = false>
class ShareObjectPool
{
    /**
    * @brief inner ctor class for Pool
    */
    template< class ClassType, bool ThreadSafe = false>
    class Ctor
    {
    public:
        Ctor()
        {//ctor
            int capacity = ShareObjectPool<ClassType, ThreadSafe>::capacity;
            auto pool = ShareObjectPool<ClassType, ThreadSafe>::_pool;
            for (int i = 0; i < capacity; i++)
            {
                pool[i] = nullptr;
            }
            ShareObjectPool<ClassType, ThreadSafe>::PreAlloc();
        }
        ~Ctor()
        {//dtor
            ShareObjectPool<ClassType, ThreadSafe>::Clear();
            //如果编译报错 那么证明不是约束下的 子类关系 请确认
            ClassType * s = nullptr;
            s->___type_sub_class_restrain__SharedObjectRecycleable();
        }
    };
    ShareObjectPool();
    static int capacity;
    static ClassType** _pool;
    static int size;
    static std::mutex _mutex;

private:
    /**
    * @brief resize inner pool growing by twice
    * @warning this will copy old block and delete old
    */
    static void ReSize()
    {
        auto pool = new ClassType*[capacity * 2];//
        memset(pool, 0, sizeof(ClassType*)* 2 * capacity);
        memcpy(pool, _pool, sizeof(ClassType*)* capacity);
        capacity *= 2;
        delete _pool;
        _pool = pool;
    }
    static void PreAlloc()
    {
        auto pool = _pool;
        for (int i = 0; i < OBJECT_POOL_DEFAULT_ALLOC_OBJECT_SIZE; i++)
        {
            pool[size] = new ClassType();
            ++size;
        }
    }
public:
    /**
    * @brief  call this to new class who is the sub-class of ShareObjectRecycleable
    * @note if class size if smaller than OBJECT_POOL_MIN_SIZEOF will new otherwise will gen object from pool
    */
    static share_ptr<ClassType, ThreadSafe> Create()
    {
        if (ThreadSafe)
        {
            ClassType * ret = nullptr;
            {
                std::lock_guard<std::mutex> locker(_mutex);
                static ShareObjectPool<ClassType, ThreadSafe>::Ctor<ClassType, ThreadSafe> ctor;//c11 compiler suport thread-safe
                if (size > 0 && sizeof(ClassType) >= OBJECT_POOL_MIN_SIZEOF)
                {
                    --size;
                    ret = (_pool[size]);
                    _pool[size] = nullptr;
                }
            }
            if (!ret)
            {
                ret = new ClassType();
            }
            ret->ctor();
            return share_ptr<ClassType, ThreadSafe>(ret);
        }
        else
        {
            static ShareObjectPool<ClassType, ThreadSafe>::Ctor<ClassType, ThreadSafe> ctor;//c11 compiler suport thread-safe
            if (size > 0 && sizeof(ClassType) >= OBJECT_POOL_MIN_SIZEOF)
            {
                --size;
                ClassType* ret = (_pool[size]);
                _pool[size] = nullptr;
                ret->ctor();
                return  share_ptr<ClassType, ThreadSafe>(ret);
            }
            //ctor will be call in share_ptr::share_ptr();
            return  share_ptr<ClassType, ThreadSafe>();
        }
    }
    /**
    * @brief release object to the pool
    * @note this will not call manual ShareObjectRecycleable will call this function automatic
    * @note if sizeof class is smaller than OBJECT_POOL_MIN_SIZEOF will delete now otherwise will put into pool
    */
    static void Release(ClassType* who)
    {
        if (!who)return;
        who->dtor();
        if (sizeof(ClassType) < OBJECT_POOL_MIN_SIZEOF)
        {
            delete who;
            return;
        }
        if (ThreadSafe)
        {
            std::lock_guard<std::mutex> locker(_mutex);
            if (size >= OBJECT_POOL_MAX_SIZE)
            {
                cout << capacity << " " << typeid(ObjectPool<ClassType, ThreadSafe>).name() << " warnning Release out-of-size" << endl;
                delete who;
                return;
            }
            if (size >= capacity)
            {
                ReSize();
            }
            _pool[size] = who;
            ++size;
        }
        else
        {
            if (size >= OBJECT_POOL_MAX_SIZE)
            {
                cout << capacity << " " << typeid(ObjectPool<ClassType, ThreadSafe>).name() << " warnning Release out-of-size" << endl;
                delete who;
                return;
            }
            if (size >= capacity)
            {
                ReSize();
            }
            _pool[size] = who;
            ++size;
        }
    }
    /**
    * @brief  delete all objects in this pool
    */
    static void Clear()
    {
        if (ThreadSafe)
        {
            std::lock_guard<std::mutex> locker(_mutex);
            if (size <= 0)return;
            for (int i = 0; i < size; i++)
            {
                if (_pool[i])
                {
                    delete _pool[i];
                    _pool[i] = nullptr;
                }
            }
            size = 0;
        }
        else
        {
            if (size <= 0)return;
            for (int i = 0; i < size; i++)
            {
                if (_pool[i])
                {
                    delete _pool[i];
                    _pool[i] = nullptr;
                }
            }
            size = 0;
        }
    }
    inline static int Size()
    {
        if (ThreadSafe)
        {
            std::lock_guard<std::mutex> locker(_mutex);
            return  size
        }
        else
        {
            return  size
        }
    }
    /**
    * @brief print current pool status for debug
    */
    static    void PrintStatus()
    {
        int total = (sizeof(ClassType)* size);
        if (total < 1024)
        {
            cout << "capacity:" << capacity << " size:" << size << " memeory:" << (sizeof(ClassType)* size) << "B " << typeid(ShareObjectPool<ClassType, ThreadSafe>).name() << endl;
        }
        else if (total < 1024 * 1024)
        {
            cout << "capacity:" << capacity << " size:" << size << " memeory:" << (sizeof(ClassType)* size) / 1024.0 << "KB " << typeid(ShareObjectPool<ClassType, ThreadSafe>).name() << endl;
        }
        else
        {
            cout << "capacity:" << capacity << " size:" << size << " memeory:" << (sizeof(ClassType)* size) / 1024.0 / 1024.0 << "MB " << typeid(ShareObjectPool<ClassType, ThreadSafe>).name() << endl;
        }
    }
};
template<class ClassType, bool ThreadSafe>
ClassType**ShareObjectPool<ClassType, ThreadSafe>::_pool = new ClassType*[OBJECT_POOL_DEFAULT_ALLOC_SIZE];//
template<class ClassType, bool ThreadSafe>
int ShareObjectPool<ClassType, ThreadSafe>::size = 0;
template<class ClassType, bool ThreadSafe>
std::mutex ShareObjectPool<ClassType, ThreadSafe>::_mutex;
template<class ClassType, bool ThreadSafe>
int ShareObjectPool<ClassType, ThreadSafe>::capacity = OBJECT_POOL_DEFAULT_ALLOC_SIZE;




//T 只能是 SharedObjectRecycleable的子类
//12 bytes use in x86
//20 bytes use in x64
//ThreadSafe just mean ShareObjectPool not this class(share_ptr)
//this class is thread safe base-on std::shared_ptr
template<typename T, bool ThreadSafe = false>
class share_ptr
{
    struct __inner_ref_wrapper
    {
    };
public:
    //请勿随便使用该变量 除非你知道你在干什么
    T * raw = nullptr;//4 bytes
    //请勿随便使用该变量 除非你知道你在干什么
    std::shared_ptr<__inner_ref_wrapper> __ptr = nullptr;//8 bytes
    ~share_ptr()
    {
        //thread-safe
        if (__ptr.use_count() == 1)//only self ref this
        {
            //如果编译报错 那么证明不是约束下的 子类关系 请确认
            ShareObjectPool<T, ThreadSafe>::Release((raw));
            //    ptr = NULL;
        }
    }
    inline    T *operator->()  const
    {
        return  this->raw;
    }
    share_ptr<T, ThreadSafe >& operator = (const share_ptr<T, ThreadSafe> & other)
    {
        this->__ptr = other.__ptr;
        this->raw = other.raw;
        return *this;
    }
    share_ptr() :
        __ptr(std::make_shared<share_ptr<T, ThreadSafe >::__inner_ref_wrapper>()), raw(new T())
    {
        //new T will call ctor 不在Pool里面调用ctor是为了减少一个share_ptr的 构造
        raw->ctor();
    }

    share_ptr(T*t) :
        __ptr(std::make_shared<share_ptr<T, ThreadSafe >::__inner_ref_wrapper>()), raw(t)
    {
    }
    share_ptr<T, ThreadSafe >(const share_ptr<T, ThreadSafe > &other) :
        __ptr(other.__ptr), raw(other.raw)
    {
    }
};
/*
该函数无意义 因为不允许 不和Pool一起使用
template<typename T, bool ThreadSafe = false>
inline share_ptr<T, ThreadSafe> make_share()
{
return share_ptr<T, ThreadSafe>();
}*/


//ThreadSafe just mean ObjectPool not this class(RawObjectRecycleable)
template<typename SubClassType, bool ThreadSafe = false>
class RawObjectRecycleable :public RawObject, public Recycleable
{
public:
    inline void Release()override
    {
        ObjectPool<SubClassType, ThreadSafe>::Release((SubClassType*)this);
    }
};
//ThreadSafe just mean ObjectPool not this class(RefObjectRecycleable)
template<typename SubClassType, bool ThreadSafe = false>
class RefObjectRecycleable :public RefObject, public Recycleable
{
public:
    inline    void Release() override
    {
        --referenct_count;
        if (referenct_count <= 0)
        {
            referenct_count = 0;
            ObjectPool<SubClassType, ThreadSafe>::Release((SubClassType*)this);
        }
    }
};

//这个 和 其他的不一样 用法比较特别 因为要支持pool
//创建请用ShareObjectPool<>::Create OR make_share
template<typename SubClassType>
class SharedObjectRecycleable : public Recycleable
{
public:
    //tag for class share_ptr T must is the sub-class of this class
    //泛型约束
    inline void ___type_sub_class_restrain__SharedObjectRecycleable()
    {
    }
};


#include<iostream>
#include "functional"
#include <chrono>
#include <thread>
using namespace std;
//cpp文件全部都是 测试代码 和 示例代码

class SharedObjectRecycleable111 :public SharedObjectRecycleable<SharedObjectRecycleable111>
{
public:
    SharedObjectRecycleable111()
    {
        cout << "SharedObjectRecycleable111:SharedObjectRecycleable111" << endl;
    }
    ~SharedObjectRecycleable111()
    {
        cout << "~~SharedObjectRecycleable111:~SharedObjectRecycleable111 " << this << endl;
    }
    virtual void ctor()
    {

    }
    virtual void dtor()
    {
        xx = 10;
    }
    void print()
    {
        cout << "     " << (++xx) << endl;

    }
    int xx = 10;
    char sqdfqsd[30];//
};


class SharedObjectRecycleable222222 :public SharedObjectRecycleable<SharedObjectRecycleable222222>
{
public:
    SharedObjectRecycleable222222()
    {
        //        cout << "SharedObjectRecycleable222222:SharedObjectRecycleable222222" << endl;
    }
    ~SharedObjectRecycleable222222()
    {
        //    cout << "~~SharedObjectRecycleable222222:~SharedObjectRecycleable222222 " << this << endl;
    }
    virtual void ctor()
    {

    }
    virtual void dtor()
    {
        xx = 10;
    }
    void print()
    {
        //    cout << "     " << (++xx) << endl;

    }
    int xx = 10;
    char sqdfqsd[10240000];//
};


class RefObject2222 :public RefObject
{
public:
    RefObject2222()
    {
        cout << "RefObject2222:RefObject2222" << endl;
    }
    ~RefObject2222()
    {
        cout << "~~RefObject2222:~RefObject2222 " << this << endl;
    }
};


class RefObject1111 :public RefObject
{
public:
    RefObject1111()
    {
        cout << "RefObject1111:RefObject1111" << endl;
        this->img = new RefObject2222();//默认图片

    }
    ~RefObject1111()
    {
        cout << "~~RefObject1111:~RefObject1111 " << this << endl;
        if (this->img)
        {
            this->img->Release();//计数-1
        }
    }
public:
    void SetImage(RefObject2222 * img)
    {
        if (this->img)
        {
            this->img->Release();//计数-1
        }
        img->Retain();//计数+1
        this->img = img;
    }
    RefObject2222 * img = nullptr;
};





class RefObjectRecycleable22222222 :public RefObjectRecycleable<RefObjectRecycleable22222222>
{
public:
    RefObjectRecycleable22222222()
    {
        cout << "RefObjectRecycleable22222222:RefObjectRecycleable22222222" << endl;
    }
    ~RefObjectRecycleable22222222()
    {
        cout << "~~RefObjectRecycleable22222222:~RefObjectRecycleable22222222 " << this << endl;
    }
    void ctor() {};
    void dtor(){};
    char sqdfqsd[1024];//
};


class RefObjectRecycleable1111111111 :public RefObjectRecycleable<RefObjectRecycleable1111111111>
{
public:
    void ctor() {};
    void dtor(){};
    RefObjectRecycleable1111111111()
    {
        cout << "RefObjectRecycleable1111111111" << endl;
        this->img = ObjectPool<RefObjectRecycleable22222222>::Create();//默认图片

    }
    ~RefObjectRecycleable1111111111()
    {
        cout << "~~RefObjectRecycleable1111111111 " << this << endl;
        if (this->img)
        {
            this->img->Release();//计数-1
        }
    }
    char sqdfqsd[1024];//
public:
    void SetImage(RefObjectRecycleable22222222 * img)
    {
        if (this->img)
        {
            this->img->Release();//计数-1
        }
        img->Retain();//计数+1
        this->img = img;
    }
    RefObjectRecycleable22222222 * img = nullptr;
};





class SharedObject111 :public SharedObject<SharedObject111>
{
public:
    SharedObject111()
    {
        cout << "SharedObject111:SharedObject111" << endl;
    }
    ~SharedObject111()
    {
        cout << "~~SharedObject111:~SharedObject111 " << this << endl;
    }
};

class RawObjectRecycleable11111111 : public RawObjectRecycleable<RawObjectRecycleable11111111>
{
public:
    RawObjectRecycleable11111111()
    {
        cout << "RawObjectRecycleable11111111" << endl;
    }
    ~RawObjectRecycleable11111111()
    {
        cout << "~~RawObjectRecycleable11111111 " << this << endl;
    }
    int x = 5;
    void print()
    {
        cout << "print" << endl;
    }
    void ctor() {};
    void dtor(){};

    char sss[1024];

};

class RawObjectRecycleable666666 : public RawObjectRecycleable<RawObjectRecycleable666666, true>
{
public:
    RawObjectRecycleable666666()
    {
        //    cout << "RawObjectRecycleable666666" << endl;
    }
    ~RawObjectRecycleable666666()
    {
        //cout << "~~RawObjectRecycleable666666 " << this << endl;
    }
    int x = 5;
    void print()
    {
        cout << "print " << (++x) << endl;
    }
    void ctor() {};
    void dtor(){ x = 5; };

    char sss[10240];

};



#if _WIN32
#include "windows.h"
#include <WinBase.h>  
int  calculateMS(std::function<void()> processFunc)
{
    long long _value;
    LARGE_INTEGER freq, _start, _end;
    QueryPerformanceFrequency(&freq);
    QueryPerformanceCounter(&_start);

    processFunc();

    QueryPerformanceCounter(&_end);
    _value = (_end.QuadPart - _start.QuadPart) * 1000 / freq.QuadPart;

    return _value;
}



int   calculateUS(std::function<void()> processFunc)
{
    long long _value;
    LARGE_INTEGER freq, _start, _end;
    QueryPerformanceFrequency(&freq);
    QueryPerformanceCounter(&_start);

    processFunc();

    QueryPerformanceCounter(&_end);
    _value = (_end.QuadPart - _start.QuadPart) * 1000 * 1000 / freq.QuadPart;

    return _value;
}





void func_test_benchmark_share_pool()
{
    printf("%d   \r\n\n", calculateUS([=]()
    {
        for (int i = 0; i != 10000; i++)
        {
            auto s1 =
                ShareObjectPool< SharedObjectRecycleable111>::Create();
            auto s2 =
                ShareObjectPool< SharedObjectRecycleable111>::Create();
            auto s3 =
                ShareObjectPool< SharedObjectRecycleable111>::Create();
            auto s4 =
                ShareObjectPool< SharedObjectRecycleable111>::Create();


        }
    }));

    printf("%d   \r\n\n", calculateUS([=]()
    {
        for (int i = 0; i != 10000; i++)
        {
            auto s1 = make_shared<SharedObjectRecycleable111>();
            auto s2 = make_shared<SharedObjectRecycleable111>();
            auto s3 = make_shared<SharedObjectRecycleable111>();
            auto s4 = make_shared<SharedObjectRecycleable111>();


        }
    }));
    printf("%d   \r\n\n", calculateUS([=]()
    {
        for (int i = 0; i != 10000; i++)
        {
            auto s1 = new SharedObjectRecycleable111();
            delete s1;
            auto s2 = new SharedObjectRecycleable111();
            delete s2;
            auto s3 = new SharedObjectRecycleable111();
            delete s3;
            auto s4 = new SharedObjectRecycleable111();
            delete s4;

        }
    }));
    auto s11 =
        ShareObjectPool< SharedObjectRecycleable111>::Create();


    ShareObjectPool<SharedObjectRecycleable111>::Clear();
    ShareObjectPool< SharedObjectRecycleable111>::Clear();
}

#endif

//传递方法和 std::shared_ptr 一样
void func_test_share_pool_2(share_ptr<SharedObjectRecycleable111, false> obj)
{
    //添加了一个引用
    //引用为2
    obj->print();
    cout << obj.raw << endl;
}
//测试 ShareObjectPool  和example
void func_test_share_pool()
{
    {
        {
            auto obj1 = ShareObjectPool< SharedObjectRecycleable111>::Create();

            auto obj2 = obj1;//一个拷贝 和std::shared_ptr一样 直接传递对象即可
            obj1->print();
            cout << obj1.raw << endl;
        }
        //执行到这里 没有任何引用了 已经被 回收 Pool大小为1


        //obj1 是刚刚回收的对象 和上面的是同一个对象
        auto obj1 = ShareObjectPool< SharedObjectRecycleable111>::Create();
        obj1->print();
        cout << obj1.raw << endl;

        //pool大小为0  创建了一个新的对象
        auto obj2 = ShareObjectPool< SharedObjectRecycleable111>::Create();
        obj2->print();//引用为1
        cout << obj2.raw << endl;

        func_test_share_pool_2(obj2);//执行完成后引用为1了
        //由于pool为空 所以无效
        ShareObjectPool< SharedObjectRecycleable111>::Clear();
        cout << "-------" << endl;
    }
    //大小为2 被delete
    ShareObjectPool< SharedObjectRecycleable111>::Clear();
}

void func_test_ref_object()
{
    {
        RefObject1111 *obj = new RefObject1111;//计数1
        obj->Retain();//计数2

        obj->Release();//计数1
        obj->Release();//计数0 被delete



        RefObject1111 *obj1 = new RefObject1111;//计数1
        obj1->Release();//计数0 被delete


        RefObject1111 *obj2 = new RefObject1111;//计数1
        //obj2 泄露了
    }

    cout << "............0" << endl;
    {
        RefObject2222 *img = new RefObject2222;//计数1 图片资源

        RefObject1111*sprite = new RefObject1111;//计数1 图片拥有者

        sprite->SetImage(img);//--img计数2
        img->Release();//变量img的 作用域交出控制权 img计数1
        sprite->Release();//变量sprite 交出控制权 但是无其他引用 都被delete掉了
        //img sprite 被全部清理了
    }
}


void func_test_share_object()
{
    auto obj1 = std::make_shared<SharedObject111>();//ok create one

    std::shared_ptr<SharedObject111> obj0;// none ref

    {
        auto obj1 = std::make_shared<SharedObject111>();//ok create one
        {
            auto obj2 = obj1->shared_from_this();//create new from shared
            obj0 = obj2->shared_from_this();//create from obj2
            auto obj3 = obj1;//create from obj2

        }
    }

    {
        auto obj11 = std::make_shared<SharedObject111>();//ok create one
    }
    //obj11 has been delete
    cout << "1111" << endl;
}

void func_test_raw_object_pool()
{
    auto obj1 = ObjectPool<RawObjectRecycleable11111111>::Create();
    obj1->Release();


    auto obj2 = ObjectPool<RawObjectRecycleable11111111>::Create();
    obj2->Release();

    auto obj3 = ObjectPool<RawObjectRecycleable11111111>::Create();
    obj3->Release();

    cout << "111111111111" << endl;
    ObjectPool<RawObjectRecycleable11111111, false>::Clear();

}

void func_test_ref_object_pool()
{

    RefObjectRecycleable22222222 *obj = ObjectPool<RefObjectRecycleable22222222>::Create();//计数1
    cout << "  obj " << obj << endl;
    obj->Retain();//计数2

    obj->Release();//计数1
    obj->Release();//计数0 被 ObjectPool回收

    RefObjectRecycleable22222222 *obj1 = ObjectPool<RefObjectRecycleable22222222>::Create();//计数1
    cout << "  obj1 " << obj1 << endl;
    obj1->Release();//计数0 被 ObjectPool回收


    cout << "............0" << endl;

    RefObjectRecycleable1111111111 *obj2 = ObjectPool<RefObjectRecycleable1111111111>::Create();//计数1
    cout << "  obj2 " << obj2 << endl;
    cout << "  obj2 img " << obj2->img << endl;//this img is in old  object obj



    obj2->Release();//计数0 被 ObjectPool回收




    /*    RefObject1111 *obj1 = new RefObject1111;//计数1
    obj1->Release();//计数0 被delete


    RefObject1111 *obj2 = new RefObject1111;//计数1
    //obj2 泄露了
    }

    cout << "............0" << endl;
    {
    RefObject2222 *img = new RefObject2222;//计数1 图片资源

    RefObject1111*sprite = new RefObject1111;//计数1 图片拥有者

    sprite->SetImage(img);//--img计数2
    img->Release();//变量img的 作用域交出控制权 img计数1
    sprite->Release();//变量sprite 交出控制权 但是无其他引用 都被delete掉了
    //img sprite 被全部清理了


    */

    cout << "............0" << endl;
    ObjectPool<RefObjectRecycleable22222222>::Clear();
}


void func_test_share_object_pool_thread_safe()
{
    for (int i = 0; i < 10; i++)
    {
        std::thread t([=]
        {
            int i = 300;

            while (--i>0)
            {


                auto s4 =
                    ShareObjectPool< SharedObjectRecycleable222222, true>::Create();

                //    auto obj1 = ObjectPool<RawObjectRecycleable666666, true>::Create();
                //    cout << obj1 << endl;
                //    if (obj1)    obj1->Release();
                //        ObjectPool<RawObjectRecycleable666666, true>::Clear();
            }
            cout << "............thread exit" << endl;
        });
        t.detach();
    }
    this_thread::sleep_for(std::chrono::milliseconds(20));

    ShareObjectPool< SharedObjectRecycleable222222, true>::PrintStatus();

    ShareObjectPool< SharedObjectRecycleable222222, true>::Clear();
}

void func_test_raw_object_pool_thread_safe()
{
    for (int i = 0; i < 10; i++)
    {
        std::thread t([=]
        {
            int i = 3000;

            while (--i>0)
            {
                auto obj1 = ObjectPool<RawObjectRecycleable666666, true>::Create();
                obj1->Release();


                auto obj2 = ObjectPool<RawObjectRecycleable666666, true>::Create();
                obj2->Release();


            }
            cout << "............thread exit" << endl;
        });
        t.detach();
    }

    this_thread::sleep_for(std::chrono::milliseconds(20));

    auto obj1 = ObjectPool<RawObjectRecycleable666666, true>::Create();
    obj1->Release();


    ObjectPool< RawObjectRecycleable666666, true>::PrintStatus();

    ObjectPool< RawObjectRecycleable666666, true>::Clear();


}

static std::mutex  __mutex;
void __func_mutex()
{
    //    std::lock_guard<std::mutex> loc(__mutex);
    __mutex.lock();
    static int xx = 0;
    xx++;
    __mutex.unlock();
}

void func_test_raw_object_pool_thread_safe__bug_()
{
    for (int i = 0; i < 10; i++)
    {
        std::thread t([=]
        {
            int i = 30000;
            while (i>0)
            {
                //        std::this_thread::yield();
                //Sleep(1);// will reduce bug rate
                __func_mutex();//BUG when main function return static variable _mutex was destroy but sub-thread still use this.
                //mutex destroyed while busy
                //TODO fixed me
            }
            cout << "............thread exit" << endl;
        });
        t.detach();
    }
    this_thread::sleep_for(std::chrono::milliseconds(2000));

}

int main(int argc, char* argv[])
{
    func_test_raw_object_pool_thread_safe__bug_();

    //    func_test_raw_object_pool_thread_safe();
    //Sleep(10000000);// 20 second
    //exit(0);
    system("pause");


    return 0;
}
Andriod第三方源码分析

Android进阶之旅-(Framework源码分析)

热门文章
