单例模式是23种设计模式中最简单、最常见的设计模式之一，许多人学习设计模式，第一个接触到的就是单例模式。
单例模式属于创建型模式，其目的是在当前进程中只创建一个实例，也可能是一个线程中属于单例。
想要写出安全又简洁的单例模式，如果不注意细节，很容易有潜在的bug，本文总结了最常见的4种单例模式写法，并分析每种优缺点。
懒汉模式
懒汉模式，就是在用的时候才会被创建，体现的是一种延迟加载的思想。
public class Singleton { private static Singleton instance; private Singleton (){} public static Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } }
这种写法lazy loading很明显，但是致命的是在多线程环境下不能正常工作，再来看看并发安全的懒汉模式。
public class Singleton { private static Singleton instance; private Singleton (){} public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } }
这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是synchronized加锁之后，每次获取单例都需要上锁，所以效率很低，99%情况下不需要同步。再看下它的优化版：
public class Singleton { private volatile static Singleton singleton; private Singleton () {} public static Singleton getSingleton() { if (singleton == null) { synchronized (Singleton.class) { if (singleton == null) { singleton = new Singleton(); } } } return singleton; } }
这就是大名鼎鼎的双重检查锁方式，也有人质疑这种单例模式的可靠性，这里笔者不做过多讲解，有兴趣的伙伴可以去网上搜索：double-checked locking is broken。
需要注意的是，singleton实例变量必须加volatile关键字。加volatile，这里主要使用了它的有序性特性，可以禁止指令重排。有许多的博客作者说是利用了volatile的可见性，并不是的。
singleton = new Singleton();
是由三个步骤组成的：
-
为对象分配内存
-
实例化对象
-
将引用指向对应的内存地址
第2，3步可能发生指令重排列，第一个线程先将singleton指向一个未实例化对象的内存地址，然后再进行实例化对象。
若此时第二个线程进行第一个非空判断时，则为false，会直接返回还没有实例化对象的内存地址，从而可能产生空指针异常。
饿汉模式
饿汉模式就是在使用前，实力已经被创建了。其实现代码如下：
public class Singleton { private static Singleton instance = new Singleton(); private Singleton (){} public static Singleton getInstance() { return instance; } }
这种方式基于classloder机制避免了多线程的同步问题，instance在类装载时就实例化，显然没有达到lazy loading的效果，也有变种写法。
public class Singleton { private Singleton instance = null; static { instance = new Singleton(); } private Singleton () {} public static Singleton getInstance() { return this.instance; } }
静态内部类
这是我在代码中比较常用的一种写法。
public class Singleton { private static class SingletonHolder { private SingletonHolder() {} private static final Singleton INSTANCE = new Singleton(); public static final Singleton getInstance() { return INSTANCE; } } public static Singleton getSingleton() { return SingletonHolder.getInstance(); }}
或者：
public class Singleton2 { private Singleton2() {} private static final class Singleton2Holder { public static final Singleton2 INSTANCE = new Singleton2(); } public static Singleton2 getInstance() { return Singleton2Holder.INSTANCE; }}
这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，
这种方式与饿汉模式不同的是，是Singleton类被装载了，instance不一定被初始化，有lazy loading效果。
枚举
枚举和静态代码块的特性相似，使用枚举时，构造方法会被自动调用，也可以利用这个特性实现单例模式，不过比较少见。
public class EnumSingleton{ private EnumSingleton(){} public static EnumSingleton getInstance(){ return Singleton.INSTANCE.getInstance(); } private static enum Singleton{ INSTANCE; private EnumSingleton singleton; //JVM会保证此方法绝对只调用一次 private Singleton(){ singleton = new EnumSingleton(); } public EnumSingleton getInstance(){ return singleton; } }}
public static void main(String[] args) { EnumSingleton obj1 = EnumSingleton.getInstance(); EnumSingleton obj2 = EnumSingleton.getInstance(); System.out.println("obj1==obj2?" + (obj1==obj2)); // true}
总结：
单例模式主要有懒汉模式、饿汉模式、内部类、基于枚举，4种写法，基于内部类的方式比较常见，也是比较推荐的方式。
设计模式单纯的使用比较简单，在许多复杂的业务场景，常常会把多种模式混合起来使用，比如单例模式+工厂模式。而且重要的是融会贯通，不在于死记硬背，这样才能灵活多变的应用。
END
