单例模式的写法

基本点：

1）构造函数私有化

2）一个static成员变量存放单例实例引用

3）一个static的 getInstance()方法来提供单例访问

其他考虑的问题

1）lazy or eager initialization

2）线程安全

如果不太在乎lazy，最简单的就是用一个static 变量在声明时候就把单例创建 好，这样不需要考虑线程安全问题。在单例类装载的时候就创建了对象，如果还有其他静态方法就可能不lazy了。当然，如果只有一个静态方法（getInstance())，也就是类的初始化和getInstance是一致的，就不是问题了。

Class Singleton {
	private static Singleton instance = new Singleton();
	private Singleton(){}
	public Singleton getInstance(){
		return instance;
	}
}

如果需要保证lazy，把静态成员换成一个私有静态内部类的静态成员，这样，当用户code引用到单例类的时候不一定创建实例，只有引用到getInstance的时候才创建，因为这个内部类只被getInstance引用。

Class Singleton {
	private static class Holder {
		static Singleton instance = new Singleton();
	}
	public static getInstance() {
		return Holder.instance;
	}
	private Singleton(){}
}

利用系统的类初始化解决线程安全问题，利用私有静态内部类实现lazy。为什么是私有内部类？——封装原则、最小化原则，最重要的，只被getInstance()引用，初始化和getInstance()被第一次调用是同时的。为什么是static？——因为不需要和包含类的某个实例绑定。

c++的单例

1.基于指针和堆对象的。

这种和java的比较像，也是三要素1）构造函数私有化。2）静态指向单例的指针成员。3）静态的访问函数getInstance()。但是注意c++没有垃圾回收，要考虑这个单例怎么销毁，也可以定义个私有内部类，其析构函数delete 单例，然后声明为单列类的静态成员变量，利用静态成员/静态变量一定会被析构的特点来destroy单例堆对象。

class CSingleton
{
private:
	CSingleton()
	{
	}
	static CSingleton *m_pInstance;
	class CGarbo   //它的唯一工作就是在析构函数中删除CSingleton的实例
	{
	public:
		~CGarbo()
		{
			if(CSingleton::m_pInstance)
				delete CSingleton::m_pInstance;
		}
	};
	static CGarbo Garbo;  //定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数
public:
	static CSingleton * GetInstance()
	{
		if(m_pInstance == NULL)  //判断是否第一次调用
			m_pInstance = new CSingleton();
		return m_pInstance;
	}
};

2 基于引用和静态变量的（非lazy)

1）getInstance()中的局部静态变量来存instance

2)  返回引用

3）需要把构造函数、拷贝构造函数都私有化

class CSingleton
{
private:
	CSingleton()   //构造函数是私有的
	{
	}
	CSingleton(const CSingleton &);
	CSingleton & operator = (const CSingleton &);
public:
	static CSingleton & GetInstance()
	{
		static CSingleton instance;   //局部静态变量
		return instance;
	}
};