设计模式之单件模式（Singleton Pattern）

一.单件模式是什么？

单件模式也被称为单例模式，它的作用说白了就是为了确保“该类的实例只有一个”

单件模式经常被用来管理资源敏感的对象，比如：数据库连接对象、注册表对象、线程池对象等等，这种对象如果同时存在多个的话就会造成各种不一致的麻烦（你总不希望发生数据库重复连接的异常吧）

二.如何保证类的实例只有一个？

（这个问题看似简单，但如果没有接触过单件模式的话，要自己想出来解决方案还是需要一些天赋的。。不信的话，可以试着想想。。）

1.类的实例可能只有一个吗？貌似只要知道类名就可以随便new了吧？

当然可以，知道类名的话，确实可以调用其构造方法来new实例，但是，注意一点：这个类必须要有公开的构造方法才能从外部new实例，不是吗？

2.那就是说要保证类的实例只有一个的话，这个类不能有公开的构造方法，对吧？

没错，就是这样，我们需要定义一个私有的构造方法

3.一个没有公开构造方法的类能够产生实例吗？如果构造方法是private，那么只有该类的实例才能调用这个构造方法，同样的要调用这个构造方法才能产生该类的实例。。这不是“鸡生蛋，蛋生鸡。。”的问题吗？

用私有的构造方法当然可以生产实例，上面忽略了一点：并不是“只有该类的实例才能调用这个构造方法”

因为在该类内部就可以随便调用这个私有的构造方法，并不需要创建任何实例

-------

有了上面的讨论结果，我们就可以实现经典的单件模式了：

package SingletonPattern;

/**
 * @author ayqy
 * 最经典的单件模式
 */
public class Singleton {

	private static Singleton instance;//定义静态实例变量

	/**
	 * 定义私有构造方法，防止从外部new实例
	 */
	private Singleton(){
		//初始化操作
	}

	/**
	 * 提供全局访问点
	 * @return 该类的实例
	 */
	public static Singleton getInstance(){
		if(instance == null)
			instance = new Singleton();
		return instance;
	}

	/*
	 * 其它有用的属性和行为
	 * 毕竟应用了单件模式的类仍然具有原本的功能
	 * */
}

注意：一定要清楚最后一点，应用了单件模式的类并不应该丧失其原本的功能，千万不能为了使用而使用

三.继续思考我们的单件模式

我们的单件模式已经万无一失了吗？

不，它还存在很多问题，比如：

1.多线程环境下

2.多个class loader环境下

我们无法保证产生的实例只有一个，对吧？

但是作为一种成熟的设计模式，单件模式必须要能从容应对这些环境，所以，接下来我们将讨论如何应对这些环境

四.多线程环境下的单件模式

如何在多线程环境下保证实例的唯一性？

很容易想到用synchronized关键字来保证线程安全，就像这样：

/**
 * 提供全局访问点
 * @return 该类的实例
 */
public static synchronized Singleton getInstance(){
	if(instance == null)
		instance = new Singleton();
	return instance;
}

我们把getInstance方法定义为同步方法就保证了不会有多个线程同时进入该方法，就不会产生不同的实例了

-------

但是上面的方法存在致命的问题：用synchronized关键字同步方法会极大的降低效率（同步一个方法甚至可能造成百倍的效率下降。。），这会拖垮我们的程序

有什么好的改进方法呢？

首先，上面的同步块是整个getIntance方法，每次调用该方法都会强制进入同步机制，但仔细一想，我们只在第一此调用该方法时需要进行同步（第一次new对象），之后的调用直接返回new好的对象就好了

那么，我们的改进方案就是：用双重加锁实现只在第一次new对象时进行同步

package SingletonPattern;

/**
 * @author ayqy
 * 多线程下的单件模式2——利用双重加锁保证只在实例化变量的时候进行同步
 */
public class DoubleLockSingleton {

	private static volatile DoubleLockSingleton instance;//定义静态实例变量

	/**
	 * 定义私有构造方法，防止从外部new实例
	 */
	private DoubleLockSingleton(){
		//初始化操作
	}

	/**
	 * 提供全局访问点
	 * @return 该类的实例
	 */
	public static DoubleLockSingleton getInstance(){
		if(instance == null)
			synchronized(DoubleLockSingleton.class){//进入同步块
				if(instance == null)//再次判空
					instance = new DoubleLockSingleton();
			}
		return instance;
	}

	/*
	 * 其它有用的属性和行为
	 * 毕竟应用了单件模式的类仍然具有原本的功能
	 * */
}

注意：双重加锁体现在volatile关键字（告诉编译器，这个变量不能被保留副本，一旦发生变动就会强制写回，避免了不一致）和synchronized修饰的同步块

但要明白这样做的代价，volatile关键字也会告诉编译器，不要对该对象进行编译优化

只看第一次new对象的过程的话，双重加锁的效率甚至要比同步方法更低，但在双重加锁方式在以后的调用中不再需要进行同步，所以长远看来双重加锁的效率要高于同步方法

-------

有没有一种方法不需要使用龟速的同步机制就能保证线程安全呢？如果有的话，绝对能够大大提高效率，对吧？

当然有，这种方法叫做“急切初始化”（顺便提一下，开篇提到的“经典单件模式”其实用了“延迟初始化”的方法。。很简单，不必解释），一起看看吧：

package SingletonPattern;

/**
 * @author ayqy
 * 多线程环境下的单件模式——用“急切初始化”来保证线程安全
 */
public class EagerlyInitSingleton {

	private static EagerlyInitSingleton instance = new EagerlyInitSingleton();//定义静态实例变量，并在类加载的时候就进行初始化操作

	/**
	 * 定义私有构造方法，防止从外部new实例
	 */
	private EagerlyInitSingleton(){
		//初始化操作
	}

	/**
	 * 提供全局访问点
	 * @return 该类的实例
	 */
	public static synchronized EagerlyInitSingleton getInstance(){
		return instance;
	}

	/*
	 * 其它有用的属性和行为
	 * 毕竟应用了单件模式的类仍然具有原本的功能
	 * */
}

额，这也能叫方法吗？这么做貌似不和标准吧？

没关系，这种方法自然有它的优点，比如：

1.效率很高，且线程安全

2.简单易用，什么都不用考虑，甚至不用判断

但其致命的缺点是：资源浪费问题，如果这个对象是一个巨大的极其耗费资源的对象，而我们在一开始就创建了它，却迟迟没有用到，这将是非常伤的。。

-------

上面提到了三种保证线程同步的方式，如何选择必须要结合具体情况来定，应综合考虑效率，资源利用等各个因素

五.多个class loader环境下的单件模式

如果存在多个类加载器，多个类加载器可能同时加载我们的单件类，从而产生多个实例

对于这种情况，我们可以显式指定使用哪一个class loader来加载单件类，这样就有效避免了上述问题

六.总结

应用单件模式可以保证对象的唯一性，但要注意单件模式的适用范围

不应该滥用单件模式，因为毕竟需要管理的资源敏感对象不会很多