【设计模式】各个击破单例模式的8种写法

单例模式

在一个系统开发过程中，我们在基于节省内存资源、保证数据内容的一致性的考虑上，往往需要对某些类要求只能创建一个实例，即「保证类只有一个实例」的设计模式就是单例模式。

比如我们遇到过的各种Manager管理类，各种Factory工厂类；

Spring 框架应用中的 ApplicationContext、数据库中的连接池等也都是单例模式。

本文旨在浅析一下单例模式的写法。

单例模式的8种写法

1. 饿汉式

/*** 类加载的时候就实例化一个实例，JVM保证线程安全* 也称饿汉式* 该方式简单实用* @author 行百里er*/
public class Singleton_1 {private static final Singleton_1 INSTANCE = new Singleton_1();/*** 私有的构造方法，其他地方不能new*/private Singleton_1() {}public static Singleton_1 getInstance() {return INSTANCE;}/*** for test*/public static void main(String[] args) {Singleton_1 instance1 = Singleton_1.getInstance();Singleton_1 instance2 = Singleton_1.getInstance();System.out.println(instance1 == instance2);}
}

这是我推荐使用的方法，简单实用，写着安心，用着放心。

2. 意思同第一种，只是写法不同

/*** 和Singleton_1是同一个意思* 只是将new的动作放在了代码块里* 类加载到内存的时候只加载一个实例* @author 行百里er*/
public class Singleton_2 {private static final Singleton_2 INSTANCE;static {INSTANCE = new Singleton_2();}/*** 私有的构造方法，其他地方不能new*/private Singleton_2() {}public static Singleton_2 getInstance() {return INSTANCE;}/*** for test*/public static void main(String[] args) {Singleton_2 instance1 = Singleton_2.getInstance();Singleton_2 instance2 = Singleton_2.getInstance();System.out.println(instance1 == instance2);}
}

和第一种写法是同一个意思，只是将new的动作放在了代码块里，类加载到内存的时候只加载一个实例。

3. 懒汉式，用到的时候才实例化

/*** 懒汉式* 这种写法虽然达到了用的时候才初始化的目的，但是存在多线程获取实例时相互影响的问题* @author 行百里er*/
public class Singleton_3 {private static Singleton_3 INSTANCE;/*** 私有的构造方法，其他地方不能new*/private Singleton_3() {}public static Singleton_3 getInstance() {if (INSTANCE == null) {// sleep一下，测试try {Thread.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}INSTANCE = new Singleton_3();}return INSTANCE;}/*** for test*/public static void main(String[] args) {//同一个类的不同对象的hashcode不同//跑100个线程，看看有没有不同的实例for (int i = 0; i < 100; i++) {new Thread(() -> System.out.println(Singleton_3.getInstance().hashCode())).start();}}
}

这种写法虽然达到了用的时候才初始化的目的，但是「存在多线程获取实例时相互影响」的问题。

运行结果：

4. 在上一种写法的基础上加synchronized锁，保证线程安全

/*** lazy loading 懒汉式* * 可以用synchronized加锁，但是效率会降低* @author 行百里er*/
public class Singleton_4 {private static Singleton_4 INSTANCE;/*** 私有的构造方法，其他地方不能new*/private Singleton_4() {}/*** 既然lazy loading的写法有线程安全问题，那就加把锁*/public static synchronized Singleton_4 getInstance() {if (INSTANCE == null) {// 测试，sleep一下，增加被其他线程打断的机会try {Thread.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}INSTANCE = new Singleton_4();}return INSTANCE;}/*** for test*/public static void main(String[] args) {//同一个类的不同对象的hashcode不同//跑100个线程，看看有没有不同的实例for (int i = 0; i < 100; i++) {new Thread(() -> System.out.println(Singleton_4.getInstance().hashCode())).start();}}
}

这种方式可行，但会带来效率下降的问题。下面继续“吹毛求疵”。

5. 那就在线程安全的基础上减少锁住的代码数量，「这里有坑」

/*** lazy loading 懒汉式* 在加锁的基础上再优化一下，减少加锁代码块的数量* @author 行百里er*/
public class Singleton_5 {private static Singleton_5 INSTANCE;/*** 私有的构造方法，其他地方不能new*/private Singleton_5() {}public static Singleton_5 getInstance() {if (INSTANCE == null) {//不在方法上加锁而在new的时候才加锁，减少锁的代码，然而这种方式并不行synchronized (Singleton_5.class) {// 测试，sleep一下，增加被其他线程打断的机会try {Thread.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}INSTANCE = new Singleton_5();}}return INSTANCE;}/*** for test*/public static void main(String[] args) {//同一个类的不同对象的hashcode不同//跑100个线程，看看有没有不同的实例for (int i = 0; i < 100; i++) {new Thread(() -> System.out.println(Singleton_5.getInstance().hashCode())).start();}}
}

先看运行结果：

说明这种写法看似在线程安全有减少了锁的代码量，其实是达不到“永远”单例的目的的。

「原因分析」：线程A运行完if(INSTANCE == null)，还没拿到锁时候，线程B也运行到if(INSTANCE == null)这一句并且拿到锁进行了new实例化，然后线程B释放锁，线程A得到锁继续运行if语句块里面的内容进行new的过程，这样就出现了不同的实例了。

6. 那就来个双重检查锁（Double Check Locking）吧

/*** 在加锁的基础上再优化一下，减少加锁代码块的数量---事实证明不可行* 那就双重检查DCL* @author 行百里er*/
public class Singleton_6 {private static Singleton_6 INSTANCE;/*** 私有的构造方法，其他地方不能new*/private Singleton_6() {}public static Singleton_6 getInstance() {if (INSTANCE == null) { //第一重检查synchronized (Singleton_6.class) {if (INSTANCE == null) { //第二重检查// 测试，sleep一下，增加被其他线程打断的机会try {Thread.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}INSTANCE = new Singleton_6();}}}return INSTANCE;}/*** for test*/public static void main(String[] args) {//同一个类的不同对象的hashcode不同//跑100个线程，看看有没有不同的实例for (int i = 0; i < 100; i++) {new Thread(() -> System.out.println(Singleton_6.getInstance().hashCode())).start();}}
}

这里，提个问题：「INSTANCE要不要加volatile」？

答案是肯定的。

「volatile」的作用是「保证线程可见性和禁止指令重排序」。在DCL单利模式写法中，volatile主要是用于禁止指令重排序的。因为如果不加volatile关键字，那么可能会出现指令重排序。

假设：一个线程A执行到 「INSTANCE = new Singleton_6()」 的时候，经过编译器编译，会分成三个指令（注意 INSTANCE 是static的）：

给指令申请内存
给成员变量初始化
把这块内存的内容赋值给INSTANCE

既然有值了，那么线程B上来先进行检查发现已经有值，就不会进入加锁那部分的代码了。

加了「volatile」后，就不允许指令重排序了。所以此时一定是保证线程A初始化完了才会复制给这个变量。

7. 静态内部类方式

/*** 静态内部类方式* JVM保证单例* 加载外部类时不会加载内部类---也可实现懒加载* @author 行百里er*/
public class Singleton_7 {/*** 私有的构造方法，其他地方不能new*/private Singleton_7() {}private static class SingletonHolder {private static final Singleton_7 INSTANCE = new Singleton_7();}public static Singleton_7 getInstance() {return SingletonHolder.INSTANCE;}/*** for test*/public static void main(String[] args) {//同一个类的不同对象的hashcode不同//跑100个线程，看看有没有不同的实例for (int i = 0; i < 100; i++) {new Thread(() -> System.out.println(Singleton_7.getInstance().hashCode())).start();}}
}

即可保证单例（虚拟机保证），也能实现懒加载。

如果非要追求完美，那么可以用这种方式。

8. 完美中的完美方式，Enum实现单例

/*** 枚举单例* 不仅可以解决线程同步，还可以防止反序列化*/
public enum Singleton_8 {INSTANCE;/*** for test*/public static void main(String[] args) {//同一个类的不同对象的hashcode不同//跑100个线程，看看有没有不同的实例for (int i = 0; i < 100; i++) {new Thread(() -> System.out.println(Singleton_8.INSTANCE.hashCode())).start();}}
}

膜拜一波这种写法！这是Java创始人之一的大神在《Effective Java》这本书中推荐的写法。

小结

虽然单例模式有这么多种写法，但不少是炫技式的花活，有点像孔乙己的“茴”字的N中写法。

这里我们理解其中有些写法的“瑕疵”和其中蕴含的“原理”就可以了。

有道无术，术可成；有术无道，止于术

欢迎大家关注Java之道公众号

好文章，我在看❤️