为了对比几种单例模式在多线程下的实际性能，我编写了一个测试类。

在这个测试类中，我使用了8线程的并发测试。每个线程分别对其进行 重复 1000000 次的获取实例对象操作，最终计算耗时并输出到控制台。

你可以通过注释/取消注释 MyThread 类中的 run 方法来测试不同单例设计模式的性能。

以下性能测试的分析，都来自我本机的测试情况。

测试类

SingletonTester

  1. import java.util.HashSet;
  3. /**
  4.  * 单例模式性能测试类
  5.  */
  6. public class SingletonTester {
  7.     public static void main(String[] args) {
  8.         MyThread thread1 = new MyThread();
  9.         MyThread thread2 = new MyThread();
  10.         MyThread thread3 = new MyThread();
  11.         MyThread thread4 = new MyThread();
  12.         MyThread thread5 = new MyThread();
  13.         MyThread thread6 = new MyThread();
  14.         MyThread thread7 = new MyThread();
  15.         MyThread thread8 = new MyThread();
  17.         thread1.setName("thread1");
  18.         thread2.setName("thread2");
  19.         thread3.setName("thread3");
  20.         thread4.setName("thread4");
  21.         thread5.setName("thread5");
  22.         thread6.setName("thread6");
  23.         thread7.setName("thread7");
  24.         thread8.setName("thread8");
  26.         thread1.start();
  27.         thread2.start();
  28.         thread3.start();
  29.         thread4.start();
  30.         thread5.start();
  31.         thread6.start();
  32.         thread7.start();
  33.         thread8.start();
  34.     }
  35. }
  38. /**
  39.  * 线程测试类
  40.  */
  41. class MyThread extends Thread {
  43.     @Override
  44.     public void run() {
  45. //        饿汉模式、线程安全
  46. //        Singleton();
  48. //        懒汉模式、线程不安全
  49. //        Singleton_1();
  51. //        懒汉模式 + synchronized同步锁、线程安全
  52.         Singleton_2();
  54. //        懒汉模式 + synchronized同步锁（移到方法体内） 、线程不安全 。（ 为了优化 Singleton_2 的性能问题改进的版本1）
  55. //        Singleton_3();
  57. //        懒汉模式 + synchronized同步锁 + double-check 、线程可能不安全（指令重排序）。（ 为了解决 Singleton_3  带来的线程不安全问题 ）
  58. //        Singleton_4();
  60. //        懒汉模式 + synchronized同步锁 + double-check + volatile 线程安全。（ 为了解决 Singleton_4 因为指令重排序可能导致的线程不安全问题 ）
  61. //        Singleton_5();
  63. //        懒汉模式 内部类实现
  64. //        Singleton_6();
  66. //        枚举方式
  67. //        Singleton_7();
  68.     }
  70.     /**
  71.      * Singleton
  72.      */
  73.     public void Singleton() {
  74.         long time1 = System.currentTimeMillis();
  76.         HashSet map = new HashSet();
  78.         for (int i = 0; i < 1000000; i++) {
  79.             boolean e = map.add(Singleton.getInstance());
  81.             if (e && i != 0) {
  82.                 System.out.println("Singleton 获取到的对象不相等，非线程安全。");
  83.                 break;
  84.             }
  85.         }
  87.         long time2 = System.currentTimeMillis();
  88.         System.out.println(this.getName() + "线程 Singleton 测试耗时：" + (time2 - time1) + "ms");
  89.     }
  92.     /**
  93.      * Singleton_1
  94.      */
  95.     public void Singleton_1() {
  96.         long time1 = System.currentTimeMillis();
  98.         HashSet map = new HashSet();
  100.         for (int i = 0; i < 1000000; i++) {
  101.             boolean e = map.add(Singleton_1.getInstance());
  103.             if (e && i != 0) {
  104.                 System.out.println("Singleton_1 获取到的对象不相等，非线程安全。");
  105.                 break;
  106.             }
  107.         }
  109.         long time2 = System.currentTimeMillis();
  110.         System.out.println(this.getName() + "线程 Singleton_1 测试耗时：" + (time2 - time1) + "ms");
  111.     }
  113.     /**
  114.      * Singleton_2
  115.      */
  116.     public void Singleton_2() {
  117.         long time1 = System.currentTimeMillis();
  119.         HashSet map = new HashSet();
  121.         for (int i = 0; i < 1000000; i++) {
  122.             boolean e = map.add(Singleton_2.getInstance());
  124.             if (e && i != 0) {
  125.                 System.out.println("Singleton_2 获取到的对象不相等，非线程安全。");
  126.                 break;
  127.             }
  128.         }
  130.         long time2 = System.currentTimeMillis();
  131.         System.out.println(this.getName() + "线程 Singleton_2 测试耗时：" + (time2 - time1) + "ms");
  132.     }
  134.     /**
  135.      * Singleton_3
  136.      */
  137.     public void Singleton_3() {
  138.         long time1 = System.currentTimeMillis();
  140.         HashSet map = new HashSet();
  142.         for (int i = 0; i < 1000000; i++) {
  143.             boolean e = map.add(Singleton_3.getInstance());
  145.             if (e && i != 0) {
  146.                 System.out.println("Singleton_3 获取到的对象不相等，非线程安全。");
  147.                 break;
  148.             }
  149.         }
  151.         long time2 = System.currentTimeMillis();
  152.         System.out.println(this.getName() + "线程 Singleton_3 测试耗时：" + (time2 - time1) + "ms");
  153.     }
  155.     /**
  156.      * Singleton_4
  157.      */
  158.     public void Singleton_4() {
  159.         long time1 = System.currentTimeMillis();
  161.         HashSet map = new HashSet();
  163.         for (int i = 0; i < 1000000; i++) {
  164.             boolean e = map.add(Singleton_4.getInstance());
  166.             if (e && i != 0) {
  167.                 System.out.println("Singleton_4 获取到的对象不相等，非线程安全。");
  168.                 break;
  169.             }
  170.         }
  172.         long time2 = System.currentTimeMillis();
  173.         System.out.println(this.getName() + "线程 Singleton_4 测试耗时：" + (time2 - time1) + "ms");
  174.     }
  176.     /**
  177.      * Singleton_5
  178.      */
  179.     public void Singleton_5() {
  180.         long time1 = System.currentTimeMillis();
  182.         HashSet map = new HashSet();
  184.         for (int i = 0; i < 1000000; i++) {
  185.             boolean e = map.add(Singleton_5.getInstance());
  187.             if (e && i != 0) {
  188.                 System.out.println("Singleton_5 获取到的对象不相等，非线程安全。");
  189.                 break;
  190.             }
  191.         }
  193.         long time2 = System.currentTimeMillis();
  194.         System.out.println(this.getName() + "线程 Singleton_5 测试耗时：" + (time2 - time1) + "ms");
  195.     }
  197.     /**
  198.      * Singleton_6
  199.      */
  200.     public void Singleton_6() {
  201.         long time1 = System.currentTimeMillis();
  203.         HashSet map = new HashSet();
  205.         for (int i = 0; i < 1000000; i++) {
  206.             boolean e = map.add(Singleton_6.getInstance());
  208.             if (e && i != 0) {
  209.                 System.out.println("Singleton_6 获取到的对象不相等，非线程安全。");
  210.                 break;
  211.             }
  212.         }
  214.         long time2 = System.currentTimeMillis();
  215.         System.out.println(this.getName() + "线程 Singleton_6 测试耗时：" + (time2 - time1) + "ms");
  216.     }
  218.     /**
  219.      * Singleton_7
  220.      */
  221.     public void Singleton_7() {
  222.         long time1 = System.currentTimeMillis();
  224.         HashSet map = new HashSet();
  226.         for (int i = 0; i < 1000000; i++) {
  227.             boolean e = map.add(Singleton_7.INSTANCE);
  229.             if (e && i != 0) {
  230.                 System.out.println("Singleton_7 获取到的对象不相等，非线程安全。");
  231.                 break;
  232.             }
  233.         }
  235.         long time2 = System.currentTimeMillis();
  236.         System.out.println(this.getName() + "线程 Singleton_7 测试耗时：" + (time2 - time1) + "ms");
  237.     }
  238. }
  240. /**
  241.  * 饿汉模式、线程安全
  242.  * 这种方式实现的单例模式，在类初始化阶段就已经在堆内存中开辟了一块内存，用于存放实例化对象，所以也称为饿汉模式。饿汉模式实现的单例的优点是，可以保证多线程情况下实例的唯一性，而且 getInstance 直接返回唯一实例，性能非常高。
  243.  * 然而，在类成员变量比较多，或变量比较大的情况下，这种模式可能会在没有使用类对象的情况下，一直占用堆内存。试想下，如果一个第三方开源框架中的类都是基于饿汉模式实现的单例，这将会初始化所有单例类，无疑是灾难性的。
  244.  */
  245. class Singleton {
  246.     private static Singleton instance = new Singleton();
  248.     private Singleton() {
  249.     }
  251.     public static Singleton getInstance() {
  252.         return instance;
  253.     }
  254. }
  256. /**
  257.  * 懒汉模式、线程不安全
  258.  * 懒汉模式就是为了避免直接加载类对象时提前创建对象的一种单例设计模式。该模式使用懒加载方式，只有当系统使用到类对象时，才会将实例加载到堆内存中
  259.  */
  260. class Singleton_1 {
  261.     private static Singleton_1 instance = null;
  263.     private Singleton_1() {
  264.     }
  266.     public static Singleton_1 getInstance() {
  267.         if (null == instance) {
  268.             instance = new Singleton_1();
  269.         }
  270.         return instance;
  271.     }
  272. }
  275. /**
  276.  * 懒汉模式 + synchronized同步锁、线程安全
  277.  * 同步锁会增加锁竞争，带来系统性能开销，从而导致系统性能下降，因此这种方式也会降低单例模式的性能。
  278.  */
  279. class Singleton_2 {
  280.     private static Singleton_2 instance = null;
  282.     private Singleton_2() {
  283.     }
  285.     public static synchronized Singleton_2 getInstance() {
  286.         if (null == instance) {
  287.             instance = new Singleton_2();
  288.         }
  289.         return instance;
  290.     }
  291. }
  294. /**
  295.  * 懒汉模式 + synchronized同步锁 、线程不安全
  296.  * 每次请求获取类对象时，都会通过 getInstance() 方法获取，除了第一次为 null，其它每次请求基本都是不为 null 的。在没有加同步锁之前，是因为 if 判断条件为 null 时，才导致创建了多个实例。基于以上两点，我们可以考虑将同步锁放在 if 条件里面，这样就可以减少同步锁资源竞争。
  297.  */
  298. class Singleton_3 {
  299.     private static Singleton_3 instance = null;
  301.     private Singleton_3() {
  302.     }
  304.     public static Singleton_3 getInstance() {
  305.         if (null == instance) {
  306.             synchronized (Singleton_3.class) {
  307.                 instance = new Singleton_3();
  308.             }
  309.         }
  310.         return instance;
  311.     }
  312. }
  315. /**
  316.  * 懒汉模式 + synchronized同步锁 + double-check 、线程可能不安全
  317.  * 这种方式，通常被称为 Double-Check，它可以大大提高支持多线程的懒汉模式的运行性能。但有可能因为 JVM 编译时的重排序而造成线程不安全。
  318.  */
  319. class Singleton_4 {
  320.     private static Singleton_4 instance = null;
  322.     private Singleton_4() {
  323.     }
  325.     public static Singleton_4 getInstance() {
  326.         if (null == instance) {
  327.             synchronized (Singleton_4.class) {
  328.                 if (null == instance) {
  329.                     instance = new Singleton_4();
  330.                 }
  331.             }
  332.         }
  333.         return instance;
  334.     }
  335. }
  337. /**
  338.  * 懒汉模式 + synchronized同步锁 + double-check + volatile 线程安全
  339.  */
  340. class Singleton_5 {
  341.     private volatile static Singleton_5 instance = null;
  343.     private Singleton_5() {
  345.     }
  347.     public static Singleton_5 getInstance() {
  348.         if (null == instance) {
  349.             synchronized (Singleton_5.class) {
  350.                 if (null == instance) {
  351.                     instance = new Singleton_5();
  352.                 }
  353.             }
  354.         }
  355.         return instance;
  356.     }
  357. }
  360. /**
  361.  * 懒汉模式 内部类实现
  362.  */
  363. class Singleton_6 {
  364.     private static Singleton_5 instance = null;
  366.     private Singleton_6() {
  368.     }
  370.     // 内部类实现
  371.     public static class InnerSingleton {
  372.         private static Singleton_6 instance = new Singleton_6();
  373.     }
  375.     public static Singleton_6 getInstance() {
  376.         return InnerSingleton.instance;
  377.     }
  378. }
  381. /**
  382.  * 枚举方式
  383.  */
  384. enum Singleton_7 {
  385.     //实例
  386.     INSTANCE;
  388.     public static Singleton_7 getInstance() {
  389.         return INSTANCE;
  390.     }
  392.     public void doSomething() {
  393.         System.out.println("doSomething");
  394.     }
  395. }

在这个测试类中，我使用了8线程的并发测试。每个线程分别对其进行 重复 1000000 次的获取实例对象操作，最终计算耗时并输出到控制台。

你可以通过注释/取消注释 MyThread 类中的 run 方法来测试不同单例设计模式的性能。

以下性能测试的分析，都来自我本机的测试情况。

Singleton

Singleton 类：饿汉模式、线程安全。

饿汉模式实现的单例的优点是，可以保证多线程情况下实例的唯一性，而且 getInstance 直接返回唯一实例，性能非常高。然而，在类成员变量比较多，或变量比较大的情况下，这种模式可能会在没有使用类对象的情况下，一直占用堆内存。试想下，如果一个第三方开源框架中的类都是基于饿汉模式实现的单例，这将会初始化所有单例类，无疑是灾难性的。

  1. class Singleton {
  2.     private static Singleton instance = new Singleton();
  4.     private Singleton() {
  5.     }
  7.     public static Singleton getInstance() {
  8.         return instance;
  9.     }
  10. }

image.png
30~50 ms

Singleton_1

Singleton_1 类：懒汉模式、线程不安全

懒汉模式就是为了避免直接加载类对象时提前创建对象的一种单例设计模式。该模式使用懒加载方式，只有当系统使用到类对象时，才会将实例加载到堆内存中。

但以这种方式实现的懒汉模式，在单线程下运行是没有问题的，但要运行在多线程下，就会出现实例化多个类对象的情况。也就是线程不安全。

  1. class Singleton_1 {
  2.     private static Singleton_1 instance = null;
  4.     private Singleton_1() {
  5.     }
  7.     public static Singleton_1 getInstance() {
  8.         if (null == instance) {
  9.             instance = new Singleton_1();
  10.         }
  11.         return instance;
  12.     }
  13. }

image.png
虽然是线程不安全的实现方式，但在正常时的性能（ 20~36 ms ）还是不错的。

Singleton_2

Singleton_2 类：懒汉模式 + synchronized同步锁、线程安全

为了解决 Singleton_1 带来的线程不安全问题，我们需要对 getInstance 方法进行加锁，保证多线程情况下仅创建一个实例。

但同步锁会增加锁竞争，带来系统性能开销，从而导致系统性能下降，因此这种方式也会降低单例模式的性能。

  1. class Singleton_2 {
  2.     private static Singleton_2 instance = null;
  4.     private Singleton_2() {
  5.     }
  7.     public static synchronized Singleton_2 getInstance() {
  8.         if (null == instance) {
  9.             instance = new Singleton_2();
  10.         }
  11.         return instance;
  12.     }
  13. }

image.png
519~532 ms
虽然是线程安全的，但性能太差了。

Singleton_3

Singleton_3 类： 懒汉模式 + synchronized同步锁 、线程不安全

每次请求获取类对象时，都会通过 getInstance() 方法获取，除了第一次为 null，其它每次请求基本都是不为 null 的。在没有加同步锁之前，是因为 if 判断条件为 null 时，才导致创建了多个实例。基于以上两点，我们可以考虑将同步锁放在 if 条件里面，这样就可以减少同步锁资源竞争。

  1. class Singleton_3 {
  2.     private static Singleton_3 instance = null;
  4.     private Singleton_3() {
  5.     }
  7.     public static Singleton_3 getInstance() {
  8.         if (null == instance) {
  9.             synchronized (Singleton_3.class) {
  10.                 instance = new Singleton_3();
  11.             }
  12.         }
  13.         return instance;
  14.     }
  15. }

image.png
虽然是线程不安全的，但可以看到，在没有获取到非单实例的情况下，性能表现已经比 Singleton_2 要好非常多了。（ 30 ms 左右 ）

Singleton_4

Singleton_4 类：懒汉模式 + synchronized同步锁 + double-check 、线程可能不安全

Singleton_3 虽然有同步锁，但是进入到判断条件里面的线程依然会依次获取到锁创建对象，然后再释放同步锁。所以我们还需要在同步锁里面再加一次判断。这种方式，通常被称为 Double-Check，它可以大大提高支持多线程的懒汉模式的运行性能。

  1. class Singleton_4 {
  2.     private static Singleton_4 instance = null;
  4.     private Singleton_4() {
  5.     }
  7.     public static Singleton_4 getInstance() {
  8.         if (null == instance) {
  9.             synchronized (Singleton_4.class) {
  10.                 if (null == instance) {
  11.                     instance = new Singleton_4();
  12.                 }
  13.             }
  14.         }
  15.         return instance;
  16.     }
  17. }

image.png
43~61 ms
可以看到，比之 Singleton_2 （懒汉模式 + synchronized同步锁）的实现方式，性能提升了接近10倍。

Singleton_5

Singleton_5 类：懒汉模式 + synchronized同步锁 + double-check + volatile 线程安全

Singleton_4 之所以说线程可能不安全的原因是：指令重排序。

在 JMM 中，重排序是十分重要的一环，特别是在并发编程中。如果 JVM 可以对它们进行任意排序以提高程序性能，也可能会给并发编程带来一系列的问题。

volatile 在 JDK1.5 之后还有一个作用就是阻止局部重排序的发生，也就是说，volatile 变量的操作指令都不会被重排序。所以使用 volatile 修饰 instance 之后，Double-Check 懒汉单例模式就万无一失了。

  1. class Singleton_5 {
  2.     private volatile static Singleton_5 instance = null;
  4.     private Singleton_5() {
  6.     }
  8.     public static Singleton_5 getInstance() {
  9.         if (null == instance) {
  10.             synchronized (Singleton_5.class) {
  11.                 if (null == instance) {
  12.                     instance = new Singleton_5();
  13.                 }
  14.             }
  15.         }
  16.         return instance;
  17.     }
  18. }

image.png31~54 ms
性能比之 Singleton_4 并没有下降。

Singleton_6

Singleton_6 类：懒汉模式 + 静态内部类 线程安全

Singleton_5 这种同步锁 +Double-Check 的实现方式相对来说，复杂且加了同步锁，使用内部类实现会更简洁一些。

InnerSingleton 是一个静态内部类，当外部类 Singleton_6 被加载的时候，并不会创建 InnerSingleton 实例对象。只有当调用 getInstance() 方法时，InnerSingleton 才会被加载，这个时候才会创建 instance。instance 的唯一性、创建过程的线程安全性，都由 JVM 来保证。所以，这种实现方法既保证了线程安全，又能做到延迟加载。

  1. class Singleton_6 {
  2.     private static Singleton_6 instance = null;
  4.     private Singleton_6() {
  6.     }
  8.     // 内部类实现
  9.     public static class InnerSingleton {
  10.         private static Singleton_6 instance = new Singleton_6();
  11.     }
  13.     public static Singleton_6 getInstance() {
  14.         return InnerSingleton.instance;
  15.     }
  16. }

image.png
30~56 ms

Singleton_7

Singleton_7 类：枚举方式实现

最后，我们介绍一种最简单的实现方式，基于枚举类型的单例实现。这种实现方式通过 Java 枚举类型本身的特性，保证了实例创建的线程安全性和实例的唯一性。

  1. enum Singleton_7 {
  2.     //实例
  3.     INSTANCE;
  5.     public static Singleton_7 getInstance() {
  6.         return INSTANCE;
  7.     }
  9.     public void doSomething() {
  10.         System.out.println("doSomething");
  11.     }
  12. }

image.png
24~50 ms
性能与 Singleton （ 饿汉模式 ） 不相上下，

总结

单例的实现方式其实有很多，但总结起来就两种：饿汉模式和懒汉模式，我们可以根据自己的需求来做选择。

如果我们在程序启动后，一定会加载到类，那么用饿汉模式实现的单例简单又实用；如果我们是写一些工具类，则优先考虑使用懒汉模式，因为很多项目可能会引用到 jar 包，但未必会使用到这个工具类，懒汉模式实现的单例可以避免提前被加载到内存中，占用系统资源。