Java 枚举实现单例模式，线程安全又优雅！

1. 双重校验锁单例（DCL）

1. public class Singleton {
3.     private static volatile Singleton singleton;
5.     private Singleton(){
6.     }
7.    
8.     public static Singleton getInstance(){
9.         if (singleton == null){
10.             synchronized (Singleton.class){
11.                 if (singleton == null){
12.                     singleton = new Singleton();
13.                 }
14.             }
15.         }
16.         return singleton;
17.     }
18. }

复制代码

这种DCL写法的优点：不仅线程安全，而且延迟加载。
1.1 为什么要double check？去掉第二次check行不行？

当然不行，当2个线程同时执行getInstance方法时，都会执行第一个if判断，由于锁机制的存在，会有一个线程先进入同步语句，而另一个线程等待，当第一个线程执行了new Singleton()之后，就会退出synchronized的保护区域，这时如果没有第二重if判断，那么第二个线程也会创建一个实例，这就破坏了单例。
1.2 singleton为什么要加上volatile关键字?

主要原因就是 singleton = new Singleton();不是一个原子操作。
在JVM中，这句语句至少做了3件事

• 给Singleton的实例分配内存空间；
  
• 调用Singleton()的构造函数，初始化成员字段；
  
• 将singleton指向分配的内存空间(此时singleton就不是null了)
  

因为存在着指令重排序的优化，第2、3步的顺序是不能保证的，最后的执行顺序可能是1-2-3，也可能是1-3-2，假如执行顺序是1-3-2，我们看看会出现什么问题

虽然singleton不是null，但是指向的空间并没有初始化，还是会报错，这就是DCL失效的问题，这种问题难以跟踪难以重现可能会隐藏很久。
JDK1.5之前JMM(Java Memory Model，即Java内存模型)中的Cache、寄存器到主存的回写规定，上面第二第三的顺序无法保证。JDK1.5之后，SUN官方调整了JVM，具体化了volatile关键字，private static volatile Singleton singleton;只要加上volatile，就可以保证每次从主存中读取（这涉及到CPU缓存一致性问题，不在本文探讨范围内，有兴趣自行搜索），也可以防止指令重排序的发生，避免拿到未完成初始化的对象。
简单讲，volatile主要就是限制JIT编译器优化，编译器优化常用的方法有：

• 将内存变量缓存到寄存器；
  
• 调整指令顺序充分利用CPU指令流水线，常见的是重新排序读写指令。
  

如果没有volatile关键字，则编译器可能优化读取，使用寄存器中的缓存值，如果这个变量由别的线程更新了的话，将出现实际值和读取的值不一致。使用了volatile后，编译器读取的时候跳过缓存，直接在内存中的实际位置读变量，写的时候通知其他缓存更新，这就是所谓的保证内存可见性，并且使用volatile还能禁止指令重排序。

1. public volatile int a = 11;
2. ......
3. int c = 6;
4. c = a;// 执行这一句的时候，在高并发情况下，a如果被修改为22，那么c会被赋值为22而不是11
5. //如果a不被volatile修饰，c有小概率被赋值为11，因为c取寄存器的缓存副本11还没来得及更新

复制代码

2. 静态内部类单例

1. public class Singleton{
2. private Singleton(){}
4. private static class SingletonInstance {
5.      private static Singleton singleton = new Singleton();
6. }
8. public static Singleton getInstance(){
9.    return SingletonInstance.singleton;
10. }
11. }

复制代码

与饿汉式的区别就在于，类加载的时候，这里并不会实例化对象，只有调用getInstance方法才会实例化对象。
和DCL优点一样，延迟加载，效率高。
虽然DCL和静态单例都不错，但是它们并不能防止反序列化和反射生成多个实例。更好的写法当然是枚举单例了！
3. 枚举单例 (推荐！！)

其他所有的实现单例的方式其实是有问题的，那就是可能被反序列化和反射破坏。
我们来看看JDK1.5中添加的枚举类来实现单例

1. public enum Singleton {
2. INSTANCE,
4. public void testMethod() {
5.   
6. }
7. }

复制代码

枚举的写法的优点：

• 不用考虑懒加载和线程安全的问题，代码写法简洁优雅
  
• 线程安全
  

反编译任何一个枚举类会发现，枚举类里的各个枚举项是是通过static代码块来定义和初始化的(可以见后面3.2节反编译分析单例枚举有分析到这个)，它们会在类被加载时完成初始化，而java类的加载由JVM保证线程安全，所以，创建一个Enum类型的枚举是线程安全的

• 防止破坏单例
  

我们知道，序列化可以将一个单例的实例对象写到磁盘，然后再反序列化读回来，从而获得一个新的实例。即使构造函数是私有的，反序列化时依然可以通过特殊的途径去创建类的一个新的实例，相当于调用该类的构造函数。
Java对枚举的序列化作了规定，在序列化时，仅将枚举对象的name属性输出到结果中，在反序列化时，就是通过java.lang.Enum的valueOf来根据名字查找对象，而不是新建一个新的对象。枚举在序列化和反序列化时，并不会调用构造方法，这就防止了反序列化导致的单例破坏的问题。
对于反射破坏单例的而言，枚举类有同样的防御措施，反射在通过newInstance创建对象时，会检查这个类是否是枚举类，如果是，会抛出异常java.lang.IllegalArgumentException: Cannot reflectively create enum objects，表示反射创建对象失败。
综上，枚举可以防止反序列化和反射破坏单例。
3.1 枚举单例模式的使用

1. // Singleton.java
2. public enum Singleton {
3.     INSTANCE;
5.     public void testMethod() {
6.         System.out.println("执行了单例类的方法");
7.     }
8. }
10. // Test.java
11. public class Test {
12. public static void main(String[] args) {
13.         //演示如何使用枚举写法的单例类
14.         Singleton.INSTANCE.testMethod();
15.         System.out.println(Singleton.INSTANCE);
16.     }
17. }

复制代码

推荐 Spring Boot 基础免费教程：

https://github.com/javastacks/spring-boot-best-practice

运行结果如下：

3.2 反编译分析单例枚举类

为了让大家进一步了解枚举类，我们将上面枚举单例类进行反编译javap -p Singleton.class，其中-p的意思是反编译的时候要包含私有方法。

1. // 这是反编译后的内容
2. public final class Singleton extends java.lang.Enum<Singleton> {
3.   public static final Singleton INSTANCE;
4.   private static final Singleton[] $VALUES;
5.   public static Singleton[] values();
6.   public static Singleton valueOf(java.lang.String);
7.   private Singleton();
8.   public void testMethod();
9.   static {};
10. }

复制代码

我们可以看到，

• INSTANCE是Singleton类的实例
  
• Singleton继承了java.lang.Enum类
  
• 这里还有一个私有的Singleton的无参构造方法，枚举类的枚举项都会使用这个构造方法来实例化，也就是说，这里的INSTANCE会使用这个构造方法来实例化。
  
• 实例化的过程发生在最后空的static代码块中，可以通过javap的其他参数进一步分析static里面的字节码内容，static里面其实包含了很多字节码指令，这些指令在做枚举项INSTANCE的初始化工作，而static代码块是在类加载的时候执行的，也就是说Singleton类被加载的时候，INSTANCE就被初始化了。static代码块里面除了初始化INSTANCE，Singleton[] $VALUES这个定义的私有的数组也是在static里面创建和初始化的。然后把所有枚举项按照定义的顺序放入这个$VALUES数组中，最后我们可以通过values方法来访问这个数组
  

为了分析每个方法中的操作，我们使用javap -p -c -v Singleton.class来看看更详细的，-c来看每个方法中的字节码，-v把常量池信息也打印出来，这里了解即可，看不懂就看我上面的结论吧，重点只需要看static代码块部分的字节码，下面是为结论做一个验证。

1. /**
2. * @author: 砖业洋__
3. * @description: 我重点只分析最后的static部分
4. */
5. public final class Singleton extends java.lang.Enum<Singleton>
6.   minor version: 0
7.   major version: 52
8.   flags: ACC_PUBLIC, ACC_FINAL, ACC_SUPER, ACC_ENUM
9. Constant pool:     // 需要注意常量池的部分，后面分析每条指令的时候可以回到这里查阅
10.    #1 = Fieldref           #4.#37         // Singleton.$VALUES:[LSingleton;
11.    #2 = Methodref          #38.#39        // "[LSingleton;".clone:()Ljava/lang/Object;
12.    #3 = Class              #17            // "[LSingleton;"
13.    #4 = Class              #40            // Singleton
14.    #5 = Methodref          #13.#41        // java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
15.    #6 = Methodref          #13.#42        // java/lang/Enum."<init>":(Ljava/lang/String;I)V
16.    #7 = Fieldref           #43.#44        // java/lang/System.out:Ljava/io/PrintStream;
17.    #8 = String             #45            // 执行了单例类的方法
18.    #9 = Methodref          #46.#47        // java/io/PrintStream.println:(Ljava/lang/String;)V
19.   #10 = String             #14            // INSTANCE
20.   #11 = Methodref          #4.#42         // Singleton."<init>":(Ljava/lang/String;I)V
21.   #12 = Fieldref           #4.#48         // Singleton.INSTANCE:LSingleton;
22.   #13 = Class              #49            // java/lang/Enum
23.   #14 = Utf8               INSTANCE
24.   #15 = Utf8               LSingleton;
25.   #16 = Utf8               $VALUES
26.   #17 = Utf8               [LSingleton;
27.   #18 = Utf8               values
28.   #19 = Utf8               ()[LSingleton;
29.   #20 = Utf8               Code
30.   #21 = Utf8               LineNumberTable
31.   #22 = Utf8               valueOf
32.   #23 = Utf8               (Ljava/lang/String;)LSingleton;
33.   #24 = Utf8               LocalVariableTable
34.   #25 = Utf8               name
35.   #26 = Utf8               Ljava/lang/String;
36.   #27 = Utf8               <init>
37.   #28 = Utf8               (Ljava/lang/String;I)V
38.   #29 = Utf8               this
39.   #30 = Utf8               Signature
40.   #31 = Utf8               ()V
41.   #32 = Utf8               testMethod
42.   #33 = Utf8               <clinit>
43.   #34 = Utf8               Ljava/lang/Enum<LSingleton;>;
44.   #35 = Utf8               SourceFile
45.   #36 = Utf8               Singleton.java
46.   #37 = NameAndType        #16:#17        // $VALUES:[LSingleton;
47.   #38 = Class              #17            // "[LSingleton;"
48.   #39 = NameAndType        #50:#51        // clone:()Ljava/lang/Object;
49.   #40 = Utf8               Singleton
50.   #41 = NameAndType        #22:#52        // valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
51.   #42 = NameAndType        #27:#28        // "<init>":(Ljava/lang/String;I)V
52.   #43 = Class              #53            // java/lang/System
53.   #44 = NameAndType        #54:#55        // out:Ljava/io/PrintStream;
54.   #45 = Utf8               执行了单例类的方法
55.   #46 = Class              #56            // java/io/PrintStream
56.   #47 = NameAndType        #57:#58        // println:(Ljava/lang/String;)V
57.   #48 = NameAndType        #14:#15        // INSTANCE:LSingleton;
58.   #49 = Utf8               java/lang/Enum
59.   #50 = Utf8               clone
60.   #51 = Utf8               ()Ljava/lang/Object;
61.   #52 = Utf8               (Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
62.   #53 = Utf8               java/lang/System
63.   #54 = Utf8               out
64.   #55 = Utf8               Ljava/io/PrintStream;
65.   #56 = Utf8               java/io/PrintStream
66.   #57 = Utf8               println
67.   #58 = Utf8               (Ljava/lang/String;)V
68. {
69.   public static final Singleton INSTANCE; // 定义枚举项
70.     descriptor: LSingleton;
71.     flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM
73.   private static final Singleton[] $VALUES; // 定义对象数组，并没有初始化，只是空引用
74.     descriptor: [LSingleton;
75.     flags: ACC_PRIVATE, ACC_STATIC, ACC_FINAL, ACC_SYNTHETIC
77.   public static Singleton[] values();
78.     descriptor: ()[LSingleton;
79.     flags: ACC_PUBLIC, ACC_STATIC
80.     Code:
81.       stack=1, locals=0, args_size=0
82.          0: getstatic     #1                  // Field $VALUES:[LSingleton;
83.          3: invokevirtual #2                  // Method "[LSingleton;".clone:()Ljava/lang/Object;
84.          6: checkcast     #3                  // class "[LSingleton;"
85.          9: areturn
86.       LineNumberTable:
87.         line 1: 0
89.   public static Singleton valueOf(java.lang.String);
90.     descriptor: (Ljava/lang/String;)LSingleton;
91.     flags: ACC_PUBLIC, ACC_STATIC
92.     Code:
93.       stack=2, locals=1, args_size=1
94.          0: ldc           #4                  // class Singleton
95.          2: aload_0
96.          3: invokestatic  #5                  // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
97.          6: checkcast     #4                  // class Singleton
98.          9: areturn
99.       LineNumberTable:
100.         line 1: 0
101.       LocalVariableTable:
102.         Start  Length  Slot  Name   Signature
103.             0      10     0  name   Ljava/lang/String;
105.   private Singleton();
106.     descriptor: (Ljava/lang/String;I)V
107.     flags: ACC_PRIVATE
108.     Code:
109.       stack=3, locals=3, args_size=3
110.          0: aload_0       // 栈操作指令，把局部方法表里的第0个位置的变量load加载到栈上来，a前缀表示它是一个引用类型。
111.        // 提醒: 当JVM执行一段代码的时候，首先会把用到的所有的变量存在一个本地变量表里————局部变量表。
112.        // 在栈上做计算的时候，需要使用局部方法表的值，就会通过load指令把它们加载到栈上来
113.        // 在栈上运算完之后，需要把值存回到局部方法表，所以也会有对应的store指令，load和store是对应的。
114.          1: aload_1
115.          2: iload_2
116.          3: invokespecial #6                  // Method java/lang/Enum."<init>":(Ljava/lang/String;I)V
117.          6: return
118.       LineNumberTable:
119.         line 1: 0
120.       LocalVariableTable:
121.         Start  Length  Slot  Name   Signature
122.             0       7     0  this   LSingleton;
123.     Signature: #31                          // ()V
125.   public void testMethod();
126.     descriptor: ()V
127.     flags: ACC_PUBLIC
128.     Code:
129.       stack=2, locals=1, args_size=1
130.          0: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
131.          3: ldc           #8                  // String 执行了单例类的方法
132.          5: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
133.          8: return
134.       LineNumberTable:
135.         line 5: 0
136.         line 6: 8
137.       LocalVariableTable:
138.         Start  Length  Slot  Name   Signature
139.             0       9     0  this   LSingleton;
141.   static {};
142.     descriptor: ()V.        // 就是代表返回void类型
143.     flags: ACC_STATIC
144.     Code:
145.       stack=4, locals=0, args_size=0
146.          0: new           #4                  // class Singleton
147.          // new #4表示从常量池里拿到标号4这个类型的名字，往上看Constant pool部分的定义可知就是Singleton这个类，然后new出来变成对象
148.          3: dup          // 然后dup压栈
149.          4: ldc           #10                 // String INSTANCE,将常量池中标号10的String类型的值INSTANCE推送到栈顶
150.          6: iconst_0        // 定义一个int类型的变量值为0，我也不知道这里定义个常量有什么卵用
151.          7: invokespecial #11                 // Method "<init>":(Ljava/lang/String;I)V，调用构造器初始化，返回类型为void
152.         10: putstatic     #12                 // Field INSTANCE:LSingleton;给INSTANCE这个静态变量赋值，和name一样
153.         13: iconst_1        // 定义一个int类型的变量值为1，然并卵
154.         14: anewarray     #4                  // class Singleton，实例化一个装Singleton枚举类型的数组，这里就是$VALUES数组
155.         17: dup
156.         18: iconst_0
157.         19: getstatic     #12                 // Field INSTANCE:LSingleton;取出字段INSTANCE的name值
158.         22: aastore         
159.         23: putstatic     #1                  // Field $VALUES:[LSingleton;将局部变量表中的枚举项的name值都依次放入$VALUES数组中
160.         26: return
161.       LineNumberTable:
162.         line 2: 0
163.         line 1: 13
164. }

复制代码

实编译完的字节码是给JVM看的，JVM只需要无脑顺序往下执行即可。多的方面就涉及JVM很多内容了，和本文主题无关，这里大家主要看static代码块中有哪些指令，明白枚举为什么会线程安全即可。
近期热文推荐：
1.1,000+ 道 Java面试题及答案整理(2022最新版)
2.劲爆！Java 协程要来了。。。
3.Spring Boot 2.x 教程，太全了！
4.别再写满屏的爆爆爆炸类了，试试装饰器模式，这才是优雅的方式！！
5.《Java开发手册（嵩山版）》最新发布，速速下载！
觉得不错，别忘了随手点赞+转发哦！