“你熟悉设计模式吗？”
“我最熟悉单例模式。”
你张开嘴巴，自信一吼，散发光彩🌈
知面不知心
即使没吃过猪肉，但也见过猪跑。问起设计模式，必不可缺少的就是单例模式。
单例模式：保证一个类只有一个实例， 并提供一个访问该实例的全局节点
翻译：创建一个唯一类对象，保证外部每次使用都是这个唯一对象。
随后你又写下实现代码，来证明自己 “很懂” 单例，毕竟它是如此简单！
- 创建单例类
public class SingleObject {
private static SingleObject instance = new SingleObject();
private SingleObject() {}
public static SingleObject getInstance() {
return instance;
}
public void showMessage() {
System.out.println("Hello World!");
}
}
- static 修饰的变量会在类加载时进行创建（记着这一点，下文会提到），并在内存中只有一份副本，使用时所有该类的实例共享同一个 static 变量。即使我们通过 对象.静态变量名 进行访问，虽对象内存不同，但访问的静态变量都是同一份，所以推荐 类名.静态变量名 进行访问更方便。
- 将 instance 设为 private 目的是保证外部无法直接使用，需要 Get 方法访问。
- 获取唯一对象并使用。
public class SingletonDemo {
public static void main(String[] args) {
SingleObject object = new SingleObject();//错误！ 因为构造私有，所以编译报错
SingleObject object = SingleObject.getInstance();//正确
object.showMessage();
}
}
上述代码是我们传统实现，也是我们最为熟悉的部分，这种实现被称之为 "饿汉式🍔"，之所以叫饿汉式是因为SingleObject instance = new SingleObject(); 无论我们是否使用 instance 对象，每当 SingleObject 类加载时就会通过 new 关键字创建对象进行内存的开辟，就犹如饿怕了的人，即使吃饱了，也要把干粮屯好，防止再受饿。
看到这里是不是觉得十分新奇，最熟悉的单例竟然开始变得陌生了！毕竟熟悉一个人从内心开始，而熟悉设计模式，也要从它的 "内心"出发。
重拾温柔的 "她"
与饿汉式相比，在类加载时不进行内存开辟，只有使用时才实例创建对象，被称之为 "懒汉式"，犹如一个人懒的觉得饿了才去吃东西。
懒汉式💤
- 线程不安全
public class Singleton {
private static Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if (instance == null) {
//线程问题
instance = new Singleton();
}
return instance;
}
}
传统懒汉式存在线程问题，假设有两个线程 T1 和 T2，同时执行上述代码，当 T1 走完 if (instance == null) 但没走到instance = new Singleton();，这个时候 T2 线程比它领先一步，执行了instance = new Singleton();将 instance 初始化。此时 T1 线程继续执行，将 instance 又重新初始化。因此会将 instance 初始化两次，从而违背了单例模式的意义。
- 线程安全
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
通过 synchronized 保证了线程安全，但是由于每个线程执行到 getInstance 方法时都得等待锁的释放，因此会影响性能，所以就有了双重校验锁模式。
双重校验锁🔒
- 错误双重校验锁
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
// Time1
synchronized (Singleton.class) {
//Time2
if (instance == null) {
instance = new Singleton(); //指令重排
}
}
}
return singleton;
}
}
第一个 if 对 instance 进行判断，如果初始化完成即 !=null 则直接返回。如果 ==null 继续执行，当多个线程执行到 Time1 时会等待锁的释放，当持有锁的线程释放后，其他线程会抢锁，然后某个线程重新拿到锁继续执行，并在 Time2 处重新判断 instance 是否为空，由于之前线程已经把 instance 初始化，所以直接返回，避免重复赋值。
但是这是理想状态，在系统中instance = new Singleton();被分为三步执行：
- 分配内存空间
- 初始化对象
- 将对象指向刚分配的内存空间
但是系统为了将性能最大化，在不影响结果的情况下，会对上述步骤重新排序，有可能是这样：
- 分配内存空间
- 将对象指向刚分配的内存空间
- 初始化对象
当 T2 线程执行到 Time2 时，此时 T1 线程执行了 "将对象指向刚分配的内存空间"，还并没有初始化对象，而未被初始化的内存空间有可能是被使用过的，是有值的（具体什么值不清楚），此时 T2 继续执行，访问到初始化未完成的 instance 对象并判断 instance 不为空，之后会将未初始化对象返回，这是错误的。❌
- 正确双重校验锁
public class Singleton {
private volatile static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
给予变量 volatile 关键字，而 volatile 作用就是禁止指令重排，因此很好的避免了上述情况。
上面太复杂？ 别急，接下来介绍用更简单的方法实现双重校验锁的功能👇。
静态内部类🌳
public class Singleton {
private static class SingletonHolder {
private static final Singleton instacne = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.instacne;
}
}
你是否还记得我上面让你记住的一句话："static 修饰的变量会在类加载时进行创建"，而通过静态内部类，即使外面一层 Singleton 类被加载，但只要我们内部 SingletonHolder 类没有主动使用，那么 instance 就不被初始化。当调用 getInstance 方法如StaticSingleton staticSingleton = StaticSingleton.getInstance();才会加载 SingletonHolder 类，实例化 instance，避免内存浪费。
文中代码来自菜鸟教程，作者略作改动！
我是 Haoo，一个乐观的码农，撰写有趣的文章。
如果这篇文章帮助到你，请收藏⭐点赞👍加关注👀，跟踪不迷路(🌻◡‿◡)
