1. Singleton 模式简介
Singleton 是GOF 圣经中最简单的一个模式了，主要用于创建在系统中具有唯一实例又需要到处使用的类，实现起来非常简单。
#include <iostream>
using namespace std;
class my_singleton
{
public:
static my_singleton *instance();
void show_my_life();
protected:
my_singleton();
private:
static my_singleton *m_instance;
};
my_singleton *my_singleton::m_instance = NULL;
my_singleton *my_singleton::instance()
{
if (m_instance == NULL)
{
m_instance = new my_singleton;
}
return m_instance;
}
void my_singleton::show_my_life()
{
cout << "i'm living at " << (void*)this << endl;
}
my_singleton::my_singleton(){}
my_singleton::~my_singleton()
{
if (m_instance != NULL)
{
delete m_instance;
m_instance = NULL;
}
}
int main()
{
my_singleton::instance()->show_my_life();
return 0;
};
2. ACE 中如何使用Singleton
如上例中，singleton 代码非常简单，也很成熟，但是如果在一个系统中有很多地方都需要使用singleton 模式，则需要写相当多的类似重复代码，枯燥且低效，如果碰巧使用了ACE ，那么使用ACE 封装的singleton ，则可以更加简单：
class normal_test
{
friend class ACE_Singleton<normal_test, ACE_Null_Mutex>;
public:
void show_my_life();
private:
normal_test();
};
normal_test::normal_test(){}
typedef ACE_Singleton<normal_test, ACE_Null_Mutex> NORMAL_TEST;
void normal_test::show_my_life()
{
cout << "i'm living at " << (void*)this << endl;
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
my_singleton::instance()->show_my_life();
NORMAL_TEST::instance()->show_my_life();
return 0;
};
如上所示，获得了以下优点：
1. 代码减少了一半还多，变得更加简洁、清晰，
2. 使用了double-check技术，免费的获得了线程安全。
3. 没有使用继承、虚函数，性能、效率不会受影响。
3. ACE 的singleton 是如何实现的？
以下代码节选自ACE 的源代码，为清晰起见，去除了一些无关的宏开关
a) 以下是ACE_Singleton 的定义：
template <class TYPE, class ACE_LOCK>
class ACE_Singleton : public ACE_Cleanup
{
public:
/// Global access point to the Singleton.
static TYPE *instance (void);
/// Cleanup method, used by <ace_cleanup_destroyer> to destroy the
/// ACE_Singleton.
virtual void cleanup (void *param = 0);
/// Dump the state of the object.
static void dump (void);
protected:
/// Default constructor.
ACE_Singleton (void);
/// Contained instance.
TYPE instance_;
/// Pointer to the Singleton (ACE_Cleanup) instance.
static ACE_Singleton<TYPE, ACE_LOCK> *singleton_;
/// Get pointer to the Singleton instance.
static ACE_Singleton<TYPE, ACE_LOCK> *&instance_i (void);
};
b) 看一下instance的实现：
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)
{
static ACE_LOCK *lock = 0;
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)
{
ACE_NEW_RETURN (singleton, (ACE_Singleton<TYPE, ACE_LOCK>), 0);
// Register for destruction with ACE_Object_Manager.
ACE_Object_Manager::at_exit (singleton);
}
}
return &singleton->instance_;
}
说明：double-check技术主要是解决线程安全问题，避免在初始化时多线程重入，导致instance被实例化两次。
c) 再看一下instance_i的实现：
template <class TYPE, class ACE_LOCK> ACE_Singleton<TYPE, ACE_LOCK> *&
ACE_Singleton<TYPE, ACE_LOCK>::instance_i (void)
{
static ACE_Singleton<TYPE, ACE_LOCK> *singleton_ = 0;
return singleton_;
}
4. 题外话：
ACE_Singleton 较好的封装了Singleton 模式，对于现代应用系统，一般而言会有相当多的地方需要使用Singleton 模式，如线程池、内存池、数据连接池等，通过ACE_Singleton 类，可以达到简化代码的目的，同时解决GOF 圣经中未提的线程安全的问题。
