「设计模式」- 教你手写单例模式
前言
单例模式（Singleton pattern）：确保一个类只有一个实例，并提供该实例的全局访问点
本文主要分析单例模式常见的几种实现方式
一. 类图
单例模式使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。
私有构造函数保证了不能通过构造函数来创建对象实例，只能通过公有静态函数返回唯一的私有静态变量。
二. 实现方式
2.1 饿汉式
饿汉式在类加载的时候就进行实例化，这样做的好处是线程安全；但缺点也是有的，首先在加载的时候就进行实例化，万一这个类占用的资源很大，就会非常浪费资源，毕竟它不一定在什么时候被使用，但内存是一开始就被占用了。
public class HungryManSingleton {
private static HungryManSingleton hungryManSingleton = new HungryManSingleton();
private HungryManSingleton() { }
public static HungryManSingleton getInstance() {
return hungryManSingleton;
}
}
复制代码在main方法中验证饿汉式实现的单例模式：
HungryManSingleton instance1 = HungryManSingleton.getInstance();
HungryManSingleton instance2 = HungryManSingleton.getInstance();
System.out.println("从饿汉单例获取的两个实例比较：" + instance1.equals(instance2));
复制代码输出：
使用反射破坏饿汉式单例模式：
//使用反射获取构造方法，再将构造方法的私有性破坏，然后用这个构造方法创建一个实例
Class singletonClass = HungryManSingleton.class;
Constructor declaredConstructor = singletonClass.getDeclaredConstructor();
declaredConstructor.setAccessible(true);
HungryManSingleton instance1 = HungryManSingleton.getInstance();
HungryManSingleton instance2 = declaredConstructor.newInstance();
System.out.println("与反射获取的实例比较：" + instance2.equals(instance1));
复制代码 输出：
可以看到，他们并不是同一个对象，这意味着饿汉式单例模式被破坏了
事实上，使用反射后，无论是饿汉式、懒汉式、升级的双重校验锁机制、静态内部类机制，都是不安全的
2.2 懒汉式
在懒汉式的实现中，默认不会进行实例化，什么时候用到了，什么时候 New，从而节约资源
public class LazySingleton {
private static LazySingleton lazySingleton;
private LazySingleton() {
System.out.println(Thread.currentThread().getName());
}
public static LazySingleton getInstance() {
if (lazySingleton == null) lazySingleton = new LazySingleton();
return lazySingleton;
}
}
复制代码但是这个实现在多线程的环境下是不安全的，试想以下，当 lazySingleton 为空时，试想一下，当lazySingleton 为空时，有多个线程同时通过了if (lazySingleton == null) 的判断，这样就会导致new 被执行了多次，使用代码复现一下：
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(() -> LazySingleton.getInstance()).start();
}
}
复制代码控制台输出：
可以看到，实例化代码被执行了三次，为了解决线程安全的问题有两个方法：
- 在
getInstance()方法的层级上加关键字synchronized - 引入双重检测锁
3.3 双重校验锁
为了解决懒汉式线程不安全的问题，可以引入双重校验锁的机制，双重检验锁也是一种延迟加载，并且较好的解决了在确保线程安全的时候效率低下的问题
以下是代码实现：
public class DCLSingleton {
private volatile static DCLSingleton dclSingleton;
private DCLSingleton() { }
public static DCLSingleton getInstance() {
if (dclSingleton == null) {
synchronized (DCLSingleton.class) {
if (dclSingleton == null) dclSingleton = new DCLSingleton();
}
}
return dclSingleton;
}
}
复制代码在这个实现中，对比一下懒汉式在方法上加锁，那么每次调用那个方法都要获得锁，释放锁，等待等待……而双重校验锁锁住了部分的代码。进入方法如果检查为空才进入同步代码块，这样很明显效率高了很多
3.3.1为什么要双重校验
那在这里为什么 dclSingleton == null 要判断两次，假设我们先去掉第二次的判断。
如果两个线程一起调用 getInstance()方法，并且都通过了第一次的判断 dclSingleton == null，那么第一个线程获取了锁，然后进行了实例化后释放了锁，然后第二个线程会开始执行，然后马上也进行了实例化，这就尴尬了。
所以加上第二次判断后，先进来的线程判断了一下，哦？为空，我创建一个，然后创建一个实例之后释放了锁，第二个线程进来之后，哎？已经有了，那我就不用创建了，然后释放了锁，开开心心的完成了单例模式。
3.3.2 为什么要使用关键字volatile
对于 new 操作来说，它不是一个原子性操作，他在底层大概发生了以下三件事：
- 在堆中分配内存空间
- 执行它的构造方法，初始化对象
- 在栈中定义引用，再把这个对象指给堆中的实际对象
我们期望它是按顺序发生的，但是由于Java的指令重排机制，可能在没有初始化对象时，就把栈中定义的引用指给堆中的空间，当第二个线程再进来的时候，第一次判定是否为空，他认为不为空，于是将还没有进行初始化的对象返回了；这就是为什么要加上关键字volatile的原因。
3.4 静态内部类实现
当 InnerClassSingleton类加载时，静态内部类 InnerClass没有被加载进内存。只有当调用 getInstance() 方法从而触发 InnerClass.INSTANCE 时 InnerClass才会被加载，初始化实例 INSTANCE。
这种方式不仅具有延迟初始化的好处，而且由虚拟机提供了对线程安全的支持。
public class InnerClassSingleton {
private InnerClassSingleton() { }
public static InnerClassSingleton getInstance() {
return InnerClass.INSTANCE;
}
static class InnerClass {
private static final InnerClassSingleton
INSTANCE = new InnerClassSingleton();
}
}
复制代码3.5 枚举
这是单例模式的最佳实践，它实现简单，并且在面对复杂的序列化或者反射攻击的时候，能够防止实例化多次
外部调用直接使用 Singleton.INSTANCE，简单粗暴。
由于 Enum 实现了 Serializable 接口，所以不用考虑序列化的问题（其实序列化反序列化也能导致单例失败的，但是我们这里不过多研究），并且加载的时候 JVM 能确保只加载一个实例，所以它是线程安全的，而且反射无法破解这种单例模式的实现
public enum Singleton {
INSTANCE;
}
复制代码总结
本文论述了单例模式常见的五种实现方式，在《Effect Java》中，作者极力推崇使用枚举类来实现单例模式，并认为这个实现是单例模式的最佳实践
感谢阅读，希望本文对你有所帮助
作者：Java雏鸡开发
链接：https://juejin.cn/post/6995836114032394277
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。