在询问 Is there a faster heap allocation/deallocation mechanism available than boost::object_pool? 后，我得到反馈说这个对象池不是线程安全的。

所以我写了一个 ObjectFactory 包装 boost::object_pool 并添加互斥锁:

#include <memory>
using std::shared_ptr;

#include <boost/pool/object_pool.hpp>
#include <boost/thread/mutex.hpp>

template <typename T>
class ObjectFactory 
{
private:
    struct SharedDeleter 
    {
        ObjectFactory<T>* m_pFact;

        SharedDeleter(ObjectFactory<T>* fact) : m_pFact(fact) {}

        inline void operator()(T* p) const 
        {      
          m_pFact->destroy(p);
        }
    };


    boost::object_pool<T>   m_Pool;
    boost::mutex            m_PoolMutex;

    SharedDeleter           m_Deleter;


public:
    ObjectFactory() : m_Deleter(this)
    {
    }

    template<typename TType = T, typename... TArgs> 
    inline TType* create(TArgs&&... mArgs)
    {
        boost::unique_lock<boost::mutex> scoped_lock(m_PoolMutex);
        return m_Pool.construct(mArgs...);
    }

    inline void destroy(T* mObj) 
    { 
        boost::unique_lock<boost::mutex> scoped_lock(m_PoolMutex);
        m_Pool.destroy(mObj); 
    }


    template<typename TType = T, typename... TArgs> 
    inline std::shared_ptr<TType> make_shared(TArgs&&... mArgs)
    {
        return std::shared_ptr<TType>(this->create(mArgs...), m_Deleter);
    }

};

没有互斥锁的计时结果:

 With WithObjectFactory!: 
Start time: 1381682855810868000 nanoseconds since Jan 1, 1970
End time: 1381682863375427000 nanoseconds since Jan 1, 1970
Duration: 7.56456 seconds

 With WithObjectFactory and std::shared_ptr!: 
Start time: 1381682863375476000 nanoseconds since Jan 1, 1970
End time: 1381682879114065000 nanoseconds since Jan 1, 1970
Duration: 15.7386 seconds

使用互斥锁的计时结果:

 With WithObjectFactory!: 
Start time: 1381683562246086000 nanoseconds since Jan 1, 1970
End time: 1381683574399319000 nanoseconds since Jan 1, 1970
Duration: 12.1532 seconds

 With WithObjectFactory and std::shared_ptr!: 
Start time: 1381683574399378000 nanoseconds since Jan 1, 1970
End time: 1381683595103438000 nanoseconds since Jan 1, 1970
Duration: 20.7041 seconds

您看到的是互斥锁定占用了超过 20% 的时间，恕我直言，boost::object_pool 仅可用于单线程应用程序。

我的问题: 我是否使用了正确的锁定机制？ destroy 是否也需要互斥锁？ 上面的代码中有没有我没有看到的错误？

谢谢

编辑: 使用 std::map 进行测试，但速度较慢。发现 boost::thread_specific_ptr 并且它似乎有效:

#include <memory>
using std::shared_ptr;

#include <boost/pool/object_pool.hpp>
#include <boost/thread.hpp>

template <typename T>
class ObjectFactory 
{
private:
    struct SharedDeleter 
    {
        ObjectFactory<T>* m_pFact;

        SharedDeleter(ObjectFactory<T>* fact) : m_pFact(fact) {}

        inline void operator()(T* p) const 
        {      
          m_pFact->destroy(p);
        }
    };

    boost::thread_specific_ptr<boost::object_pool<T>>   m_tpPool;   
    SharedDeleter           m_Deleter;

public:
    ObjectFactory() : m_Deleter(this)
    {
        if ( !m_tpPool.get() )
            m_tpPool.reset(new boost::object_pool<T>());
    }

    template<typename TType = T, typename... TArgs> 
    inline TType* create(TArgs&&... mArgs)
    {
        return m_tpPool->construct(mArgs...);
    }

    inline void destroy(T* mObj) 
    { 
        m_tpPool->destroy(mObj);
    }

    template<typename TType = T, typename... TArgs> 
    inline std::shared_ptr<TType> make_shared(TArgs&&... mArgs)
    {
        return std::shared_ptr<TType>(this->create(mArgs...), m_Deleter);
    }
};

上面代码的结果:

 With WithObjectFactory!: 
Start time: 1381714923605177000 nanoseconds since Jan 1, 1970
End time: 1381714934202228000 nanoseconds since Jan 1, 1970
Duration: 10.5971 seconds

 With WithObjectFactory and std::shared_ptr!: 
Start time: 1381714934202285000 nanoseconds since Jan 1, 1970
End time: 1381714950900537000 nanoseconds since Jan 1, 1970
Duration: 16.6983 seconds

最佳答案

• 使用 std::mutex 和 boost:thread_specific_ptr 来降低速度
• std::atomic_load(std::shared_ptr<...>*) 似乎不适用于 GCC 4.6
• 使用 this 回退到良好的旧 pthread 调用解决方案

结果:在带有 GCC 4.6 的 Ubuntu LTS 12.04 上

 With OUT smartptrs (new and delete): 
Start time: 1381746876399819258 nanoseconds since Jan 1, 1970
End time: 1381746881851990579 nanoseconds since Jan 1, 1970
Duration: 5.45217 seconds

 With smartptrs (boost::shared_ptr withOUT make_shared): 
Start time: 1381746881852079492 nanoseconds since Jan 1, 1970
End time: 1381746889453586405 nanoseconds since Jan 1, 1970
Duration: 7.60151 seconds

 With smartptrs (boost::shared_ptr with make_shared): 
Start time: 1381746889453642790 nanoseconds since Jan 1, 1970
End time: 1381746896396534068 nanoseconds since Jan 1, 1970
Duration: 6.94289 seconds

 With STD smart_ptr (std::shared_ptr with make_shared): 
Start time: 1381746896396596314 nanoseconds since Jan 1, 1970
End time: 1381746902544346880 nanoseconds since Jan 1, 1970
Duration: 6.14775 seconds

 With UniquePtr (boost::unique_ptr): 
Start time: 1381746902544386766 nanoseconds since Jan 1, 1970
End time: 1381746907842640751 nanoseconds since Jan 1, 1970
Duration: 5.29825 seconds

 With STD UniquePtr (std::unique_ptr): 
Start time: 1381746907842679994 nanoseconds since Jan 1, 1970
End time: 1381746913141429138 nanoseconds since Jan 1, 1970
Duration: 5.29875 seconds

 With Object Pool (boost::object_pool<>): 
Start time: 1381746913141469017 nanoseconds since Jan 1, 1970
End time: 1381746917062689541 nanoseconds since Jan 1, 1970
Duration: 3.92122 seconds


 With Thread Safe ObjectFactory<TestClass>...
Start time: 1381746917062729671 nanoseconds since Jan 1, 1970
End time: 1381746921388452186 nanoseconds since Jan 1, 1970
Duration: 4.32572 seconds

 With Thread Safe ObjectFactory<TestClass> and std::shared_ptr...
Start time: 1381746921388491395 nanoseconds since Jan 1, 1970
End time: 1381746928808481617 nanoseconds since Jan 1, 1970
Duration: 7.41999 seconds

因此线程安全 ObjectFactory 仍然比使用普通的旧的 new 和 delete 快 1 秒以上。

大家有更好的建议欢迎补充!

感谢所有有用的反馈!

编辑: 使用 __thread gnu 选项也可以快速工作:

#include <memory>
#include <boost/pool/object_pool.hpp>

template <typename T>
class ObjectFactory 
{
private:
    struct SharedDeleter 
    {
        ObjectFactory<T>* m_pFact;

        SharedDeleter(ObjectFactory<T>* fact) : m_pFact(fact) {}

        inline void operator()(T* p) const 
        {      
          m_pFact->destroy(p);
        }
    };

    static __thread boost::object_pool<T>* m_tlsPool;
    SharedDeleter           m_Deleter;

public:
    ObjectFactory() :  m_Deleter(this)
    {
        m_tlsPool = new boost::object_pool<T>();
    }

    virtual ~ObjectFactory() 
    {
        delete m_tlsPool;
    }

    template<typename TType = T, typename... TArgs> 
    inline TType* create(TArgs&&... mArgs)
    {
        return m_tlsPool->construct(mArgs...);       
    }

    inline void destroy(T* mObj) 
    { 
        m_tlsPool->destroy(mObj);
    }

    template<typename TType = T, typename... TArgs> 
    inline std::shared_ptr<TType> make_shared(TArgs&&... mArgs)
    {
        return std::shared_ptr<TType>(this->create(mArgs...), m_Deleter);
    }
};

template<typename T>
/*static*/__thread boost::object_pool<T>* ObjectFactory<T>::m_tlsPool(NULL);

但是 m_tlsPool 不需要是静态的吗？

关于c++ - 如何让 boost::object_pool 线程安全？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/19347890/