一.单件模式是什么？
单件模式也被称为单例模式，它的作用说白了就是为了确保“该类的实例只有一个”
单件模式经常被用来管理资源敏感的对象，比如：数据库连接对象、注册表对象、线程池对象等等，这种对象如果同时存在多个的话就会造成各种不一致的麻烦（你总不希望发生数据库重复连接的异常吧）
二.如何保证类的实例只有一个？
（这个问题看似简单，但如果没有接触过单件模式的话，要自己想出来解决方案还是需要一些天赋的。。不信的话，可以试着想想。。）
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来加载单件类，这样就有效避免了上述问题
六.总结
应用单件模式可以保证对象的唯一性，但要注意单件模式的适用范围
不应该滥用单件模式，因为毕竟需要管理的资源敏感对象不会很多