我的博客
单例模式是我们经常用到的设计模式。
优点：如果对象的数据量比较大，单例模式可以避免重复的创建对象，保证内存中只有一份实例
缺点：不易被销毁，只有程序退出才会被销毁
首先，看一下简单的步骤
public class Singleton {
/**
* 私有静态实例，防止被引用。此处赋值null是为了实现延迟加载
*/
private static Singleton singleton = null;
/**
* 私有构造方法，防止被实例化
*/
private Singleton() {
}
/**
* 公共、静态的方法,创建实例
*
* @return Singleton
*/
public static Singleton getInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
如果考虑多线程的情况，就可能出现创建多个实例的问题了。例如现在又两个线程，线程A和线程B，如果线程A正在创建实例，线程B访问 if (singleton == null) 判断，就会再次进入new Singleton()这行代码，这就出现创建两次实例的情况。为了避免这种情况，我们可以使用同步锁synchronized关键字
public static synchronized Singleton getInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
这样就保证不会出现多线程访问造成多实例的问题了。但是这里有性能问题：每次获取实例都需要获取锁，很耗费性能。其实我们只需要第一次实例化的时候用到锁。那好，我们改良一下代码。
public static Singleton getInstance() {
if (singleton == null) {
synchronized (Singleton.class){
if (singleton == null){
singleton = new Singleton();
}
}
}
return singleton;
}
这样我们就保证了只对第一次实例化的情况使用了锁。但是，这里还有一个问题：由于指针重排序，造成实例还没有初始化就开始使用实例的情况。
在这里，需要温习一下java的基础知识：、
singleton = new Singleton()
这行代码都进行了哪些操作
memory = allocate(); //1：分配对象的内存空间
ctorInstance(memory); //2：初始化对象
instance = memory; //3：设置instance指向刚分配的内存地址
上述伪代码中2和3可能重新排序，出现下面的情况
memory = allocate(); //1：分配对象的内存空间
instance = memory; //3：设置instance指向刚分配的内存地址
//注意，此时对象还没有被初始化！
ctorInstance(memory); //2：初始化对象
此时线程B就会访问一个没有初始化的对象，出现异常。为了解决上述情况，我们需要稍微修改一下代码即可：把instance 声明为volatile类型，就可以实现线程安全的延迟初始化。
private volatile static Singleton singleton = null;
public static Singleton getInstance() {
if (singleton == null) {
synchronized (Singleton.class){
if (singleton == null){
singleton = new Singleton();
}
}
}
return singleton;
}
关于volatile的作用，只需要知道使用volatile上述伪代码中的指针重新排序将被禁止就行.
上述代码已经是线程安全的单例模式了，基于volatile的双重检查锁定（DOUBLE_CHECK）的解决方案。但是代码过于复杂。接下来介绍一种最简单也是最安全的单例模式。
/**
* 获得单例
*
* @return
*/
public static Singleton getInstance() {
return InstanceHolder.INSTANCE;
}
/**
* 单例持有器
*/
private static final class InstanceHolder {
private static final Singleton INSTANCE = new Singleton();
}
/**
* 禁止构造
*/
private Singleton() {
}
这种是基于类初始化的一种解决方案。JVM在类的初始化阶段（即在Class被加载后，且被线程使用之前），会执行类的初始化。在执行类的初始化期间，JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化。基于这个特性，可以实现另一种线程安全的延迟初始化方案（这个方案被称之为Initialization On Demand Holder idiom）
总结:
延迟初始化降低了初始化类或创建实例的开销，但增加了访问被延迟初始化的字段的开销。在大多数时候，正常的初始化要优于延迟初始化。如果确实需要对实例字段使用线程安全的延迟初始化，请使用上面介绍的基于volatile的延迟初始化的方案；如果确实需要对静态字段使用线程安全的延迟初始化，请使用上面介绍的基于类初始化的方案。
