深入理解单例模式
前言
有一些对象其实我们只需要一个，比方说：线程池，缓存，对话框，处理偏好设置和注册表的对象，日志对象，充当打印机，显卡等设备的驱动程序的对象。事实上，这类对象只能有一个实例，如果制造出多个实例，就会导致许多问题产生，例如：程序的行为异常，资源使用过量，或者是不一致的结果
涉及到一些类加载的知识，如果不清楚，可以看一下这篇分享：Java类的加载顺序
单例模式确保一个类只有一个实例，并提供一个全局访问点，实现单例模式的方法是私有化构造函数，通过getInstance()方法实例化对象，并返回这个实例
实现
第一种（懒汉）
按照上面的想法，我们有了第一个实现
// code1
public class Singleton {
private static Singleton uniqueInstance;
private Singleton() {}
public static Singleton getInstance() {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
return uniqueInstance;
}
}当2个线程同时进入getInstance()的if语句里面，会返回2个不同实例，因此这种方式是线程不安全的
// code2
public class Singleton {
private static Singleton uniqueInstance;
private Singleton() {}
public static synchronized Singleton getInstance() {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
return uniqueInstance;
}
}用synchronized修饰可以保证线程安全，但是只有第一次执行此方法时才需要同步，设置好 uniqueInstance，就不需要同步这个方法了，之后每次调用这个方法，同步都是一种累赘
第二种（双重检查锁定）
synchronized锁的粒度太大，人们就想到通过双重检查锁定来降低同步的开销，下面是实例代码
// code3
public class Singleton {
private static Singleton uniqueInstance;
private Singleton() {}
public static Singleton getInstance() {
if (uniqueInstance == null) {
synchronized (Singleton.class) {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
}
}
return uniqueInstance;
}
}如上面代码所示，如果第一次检查uniqueInstance不为null，那么就不需要执行下面的加锁和初始化操作，可以大幅降低synchronized带来的性能开销，只有在多个线程试图在同一时间创建对象时，会通过加锁来保证只有一个线程能创建对象
双重检查锁定看起来似乎很完美，但这是一个错误的优化！在线程执行到getInstance()方法的第4行，代码读取到uniqueInstance不为null时，uniqueInstance引用的对象有可能还没有完成初始化
简单概述一下《Java并发编程的艺术》的解释， uniqueInstance = new Singleton()可以分解为如下三行伪代码
memory = allocate(); // 1:分配对象的内存空间
ctorInstance(memory); // 2:初始化对象
uniqueInstance = memory;// 3:设置uniqueInstance指向刚分配的内存地址3行伪代码中的2和3之间，可能会被重排序，重排序后执行时序如下
memory = allocate(); // 1:分配对象的内存空间
uniqueInstance = memory;// 3:设置uniqueInstance指向刚分配的内存地址
// 注意，此时对象还没有被初始化
ctorInstance(memory); // 2:初始化对象多个线程访问时可能出现如下情况
时间
线程A
线程B
t1
A1：分配对象的内存空间
t2
A3：设置uniqueinstance指向内存空间
t3
B1：判断uniqueinstance是否为空
t4
B2：由于uniqueinstace不为null,线程B间访问uniqueinstance引用的对象
t5
A2：初始化对象
t6
A4：访问instace引用的对象
这样会导致线程B访问到一个还未初始化的对象，此时可以用volatile来修饰Singleton，这样3行伪代码中的2和3之间的重排序，在多线程环境中将会被禁止
// code4
public class Singleton {
private volatile static Singleton uniqueInstance;
private Singleton() {}
public static Singleton getInstance() {
if (uniqueInstance == null) {
synchronized (Singleton.class) {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
}
}
return uniqueInstance;
}
}第三种（饿汉）
如果应用程序总是创建并使用单例式例，或者在创建和运行时方面的负担不太繁重，我们可以以饿汉式的方式来创建单例
// code5
public class Singleton {
private static Singleton uniqueInstance = new Singleton();
private Singleton() {}
public static Singleton getInstance() {
return uniqueInstance;
}
}// code6
public class Singleton {
private static Singleton uniqueInstance;
static {
uniqueInstance = new Singleton();
}
private Singleton() {}
public static Singleton getInstance() {
return uniqueInstance;
}
}在类加载的时候直接创建这个对象，这样既能提高效率，又能保证线程安全，code5和code6几乎没有区别，因为静态成员变量和静态代码块都是类初始化的时候被加载
第四种（静态内部类）
// code7
public class Singleton {
private static class SingletonHolder {
private static Singleton uniqueInstance = new Singleton();
}
private Singleton() {}
public static Singleton getInstance() {
return SingletonHolder.uniqueInstance;
}
}饿汉式的方式只要Singleton类被装载了，那么uniqueInstance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，uniqueInstance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化uniqueInstance
第五种（枚举）
// code8
public enum Singleton {
INSTANCE;
public void whateverMethod() {
}
}公认的实现单例的最好方式，网上资料也比较少，还没有彻底理解清楚，说不定以后会补一篇文章说明，本篇文章中的code1和code3不建议使用，原因已经说明
参考书籍
《Java并发编程的艺术》
《Head First设计模式》
腾讯云开发者
