ACE中的单例模式
ACE中的单例就是利用ACE_Singleton这个类去管理其他类的单例,需要实现一个单例类的时候只需要做两件事:
- 将自己的类T的构造和析构函数都私有化,为了防止用户去生成和释放对象。
- 然后把ACE_Singleton<T,ACE_LOCK>类声明为自己的友元类,然后就可以调用友元类的instance方法获得自己的单实例,这个单实例不用自己管理,可以使用typedef来定义看起来就像调用自身方法一样的。
ACE_Object_Manager能够对单例实例进行资源管理,在进程退出的时候,自动清理单例对象,而不用手动来释放。
template <class TYPE, class ACE_LOCK>
class ACE_Singleton : public ACE_Cleanup//继承ACE_Cleanup,是为了单例会交给系统释放
{
public:
/// Global access point to the Singleton.
static TYPE *instance (void);//返回传入的类类型的实例对象
/// Cleanup method, used by @c ace_cleanup_destroyer to destroy the
/// ACE_Singleton.
virtual void cleanup (void *param = 0);
/// Explicitly delete the Singleton instance.
static void close (void);
/// Dump the state of the object.
static void dump (void);
/// Declare the dynamic allocation hooks.
ACE_ALLOC_HOOK_DECLARE;
protected:
/// Default constructor.
ACE_Singleton (void);//私有化构造函数
/// Contained instance.
TYPE instance_;//管理一个单例是TYPE类型的
#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
/// Pointer to the Singleton (ACE_Cleanup) instance.
static ACE_Singleton<TYPE, ACE_LOCK> * singleton_;//该类对象静态对象
#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
/// Get pointer to the Singleton instance.
static ACE_Singleton<TYPE, ACE_LOCK> *&instance_i (void);
};
template <class TYPE, class ACE_LOCK>
void ACE_Singleton<TYPE, ACE_LOCK>::dump (void)
{
#if defined (ACE_HAS_DUMP)
ACE_TRACE ("ACE_Singleton<TYPE, ACE_LOCK>::dump");
#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("instance_ = %x"),
ACE_Singleton<TYPE, ACE_LOCK>::instance_i ()));
ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
#endif /* ACE_HAS_DUMP */
}
template <class TYPE, class ACE_LOCK>
ACE_Singleton<TYPE, ACE_LOCK> *& ACE_Singleton<TYPE, ACE_LOCK>::instance_i (void)
{
#if defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
// Pointer to the Singleton instance. This works around a bug with
// G++ and it's (mis-)handling of templates and statics...
static ACE_Singleton<TYPE, ACE_LOCK> *singleton_ = 0;
return singleton_;
#else
return ACE_Singleton<TYPE, ACE_LOCK>::singleton_;
#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
}
//这个方法返回其他类的单实例
template <class TYPE, class ACE_LOCK>
TYPE* ACE_Singleton<TYPE, ACE_LOCK>::instance (void)
{
ACE_TRACE ("ACE_Singleton<TYPE, ACE_LOCK>::instance");
ACE_Singleton<TYPE, ACE_LOCK> *&singleton =
ACE_Singleton<TYPE, ACE_LOCK>::instance_i ();
// Perform the Double-Check pattern...
if (singleton == 0)
{
if (ACE_Object_Manager::starting_up () ||
ACE_Object_Manager::shutting_down ())
{
// The program is still starting up, and therefore assumed
// to be single threaded. There's no need to double-check.
// Or, the ACE_Object_Manager instance has been destroyed,
// so the preallocated lock is not available. Either way,
// don't register for destruction with the
// ACE_Object_Manager: we'll have to leak this instance.
ACE_NEW_RETURN (singleton, (ACE_Singleton<TYPE, ACE_LOCK>), 0);
}
else
{
#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
// Obtain a lock from the ACE_Object_Manager. The pointer
// is static, so we only obtain one per ACE_Singleton
// instantiation.
#if defined(ACE_FACE_SAFETY_BASE)
static ACE_LOCK the_lock;
static ACE_LOCK *lock = &the_lock;
#else /* ACE_FACE_SAFETY_BASE */
static ACE_LOCK *lock = 0;
#endif /* ACE_FACE_SAFETY_BASE */
if (ACE_Object_Manager::get_singleton_lock (lock) != 0)
// Failed to acquire the lock!
return 0;
ACE_GUARD_RETURN (ACE_LOCK, ace_mon, *lock, 0);
if (singleton == 0)
{
#endif /* ACE_MT_SAFE */
ACE_NEW_RETURN (singleton, (ACE_Singleton<TYPE, ACE_LOCK>), 0);
// Register for destruction with ACE_Object_Manager.
#if !defined (ACE_MT_SAFE) || (ACE_MT_SAFE == 0)
ACE_Object_Manager::at_exit (singleton, 0, typeid (TYPE).name ());
#else
ACE_Object_Manager::at_exit (singleton, &lock,
typeid (TYPE).name ());
}
#endif /* ACE_MT_SAFE */
}
}
return &singleton->instance_;//singleton是ACE_Singleton<TYPE, ACE_LOCK>的单例,返回instance_就是T的单例
}
template <class TYPE, class ACE_LOCK> void
ACE_Singleton<TYPE, ACE_LOCK>::cleanup (void *param)
{
ACE_Object_Manager::remove_at_exit (this);
delete this;
ACE_Singleton<TYPE, ACE_LOCK>::instance_i () = 0;
#if !defined ACE_MT_SAFE || ACE_MT_SAFE == 0 || defined ACE_FACE_SAFETY_BASE
ACE_UNUSED_ARG (param);
#else
if (param)
{
ACE_LOCK **lock = static_cast<ACE_LOCK **> (param);
*lock = 0;
}
#endif
}
template <class TYPE, class ACE_LOCK> void
ACE_Singleton<TYPE, ACE_LOCK>::close (void)
{
ACE_Singleton<TYPE, ACE_LOCK> *&singleton =
ACE_Singleton<TYPE, ACE_LOCK>::instance_i ();
if (singleton)
{
singleton->cleanup ();
ACE_Singleton<TYPE, ACE_LOCK>::instance_i () = 0;
}
}
#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
// Pointer to the Singleton instance.
template <class TYPE, class ACE_LOCK>
ACE_Singleton<TYPE, ACE_LOCK>* ACE_Singleton<TYPE, ACE_LOCK>::singleton_ = 0;
class Ex
{ {
friend class ACE_Singleton<Ex, ACE_Null_Mutex>; //声明为友元类,那么这个类就可以访问该类的私有成员
private:
Ex () { cout << "Ex constructed" << endl; }
~Ex () { cout << "Ex destroyed" << endl; }
};
typedef ACE_Singleton<Ex, ACE_Null_Mutex> Ex;
这样就可以通过Ex.instance()来获得单例实例了,注意返回的是Ex类对象。
吐槽 :
这个庞大的库,代码写的真的不咋地,比起其他优秀的开源组件有点差距,看ACE的代码真的心累,本人也很菜,哈哈哈,但还是想吐槽一下,不过ACE还是有很多值得学习的地方!