关于java:Java-枚举实现单例模式线程安全又优雅

起源：https://liuchenyang0515.blog.csdn.net/article/details/121049426

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

public class Singleton {

    private static volatile Singleton singleton;

    private Singleton(){}
    
    public static Singleton getInstance(){if (singleton == null){synchronized (Singleton.class){if (singleton == null){singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

这种 DCL 写法的长处：不仅线程平安，而且提早加载。

1.1 为什么要 double check？去掉第二次 check 行不行？

当然不行，当 2 个线程同时执行 getInstance 办法时，都会执行第一个 if 判断，因为锁机制的存在，会有一个线程先进入同步语句，而另一个线程期待，当第一个线程执行了 new Singleton() 之后，就会退出 synchronized 的爱护区域，这时如果没有第二重 if 判断，那么第二个线程也会创立一个实例，这就毁坏了单例。

1.2 singleton 为什么要加上 volatile 关键字?

次要起因就是 singleton = new Singleton();不是一个原子操作。

在 JVM 中，这句语句至多做了 3 件事

1. 给 Singleton 的实例分配内存空间；
2. 调用 Singleton() 的构造函数，初始化成员字段；
3. 将 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 还能禁止指令重排序。

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

2. 动态外部类单例

public class Singleton{private Singleton(){}
 
 private static class SingletonInstance {private static Singleton singleton = new Singleton();
 }
 
 public static Singleton getInstance(){return SingletonInstance.singleton;}
}

与饿汉式的区别就在于，类加载的时候，这里并不会实例化对象，只有调用 getInstance 办法才会实例化对象。

和 DCL 长处一样，提早加载，效率高。

尽管 DCL 和动态单例都不错，然而它们并不能避免反序列化和反射生成多个实例。更好的写法当然是枚举单例了！

3. 枚举单例 (举荐！！)

其余所有的实现单例的形式其实是有问题的，那就是可能被反序列化和反射毁坏。

咱们来看看 JDK1.5 中增加的枚举类来实现单例

public enum Singleton {
 INSTANCE,

 public void testMethod() {}
}

枚举的写法的长处：

• 不必思考懒加载和线程平安的问题，代码写法简洁优雅
• 线程平安

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

• 避免毁坏单例

咱们晓得，序列化能够将一个单例的实例对象写到磁盘，而后再反序列化读回来，从而取得一个新的实例。即便构造函数是公有的，反序列化时仍然能够通过非凡的路径去创立类的一个新的实例，相当于调用该类的构造函数。

Java 对枚举的序列化作了规定，在序列化时，仅将枚举对象的 name 属性输入到后果中，在反序列化时，就是通过 java.lang.Enum 的 valueOf 来依据名字查找对象，而不是新建一个新的对象。枚举在序列化和反序列化时，并不会调用构造方法，这就避免了反序列化导致的单例毁坏的问题。

对于反射毁坏单例的而言，枚举类有同样的进攻措施，反射在通过 newInstance 创建对象时，会查看这个类是否是枚举类，如果是，会抛出异样java.lang.IllegalArgumentException: Cannot reflectively create enum objects，示意反射创建对象失败。

综上，枚举能够避免反序列化和反射毁坏单例。

3.1 枚举单例模式的应用

// Singleton.java
public enum Singleton {
    INSTANCE;

    public void testMethod() {System.out.println("执行了单例类的办法");
    }
}

// Test.java
public class Test {public static void main(String[] args) {
        // 演示如何应用枚举写法的单例类
        Singleton.INSTANCE.testMethod();
        System.out.println(Singleton.INSTANCE);
    }
}

举荐 Spring Boot 根底收费教程：

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

运行后果如下：

3.2 反编译剖析单例枚举类

为了让大家进一步理解枚举类，咱们将下面枚举单例类进行反编译javap -p Singleton.class，其中 - p 的意思是反编译的时候要蕴含公有办法。

// 这是反编译后的内容
public final class Singleton extends java.lang.Enum<Singleton> {
  public static final Singleton INSTANCE;
  private static final Singleton[] $VALUES;
  public static Singleton[] values();
  public static Singleton valueOf(java.lang.String);
  private Singleton();
  public void testMethod();
  static {};}

咱们能够看到，

• 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 代码块局部的字节码，上面是为论断做一个验证。

/**
 * @author: 砖业洋__
 * @description: 我重点只剖析最初的 static 局部
 */
public final class Singleton extends java.lang.Enum<Singleton>
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_FINAL, ACC_SUPER, ACC_ENUM
Constant pool:     // 须要留神常量池的局部，前面剖析每条指令的时候能够回到这里查阅
   #1 = Fieldref           #4.#37         // Singleton.$VALUES:[LSingleton;
   #2 = Methodref          #38.#39        // "[LSingleton;".clone:()Ljava/lang/Object;
   #3 = Class              #17            // "[LSingleton;"
   #4 = Class              #40            // Singleton
   #5 = Methodref          #13.#41        // java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
   #6 = Methodref          #13.#42        // java/lang/Enum."<init>":(Ljava/lang/String;I)V
   #7 = Fieldref           #43.#44        // java/lang/System.out:Ljava/io/PrintStream;
   #8 = String             #45            // 执行了单例类的办法
   #9 = Methodref          #46.#47        // java/io/PrintStream.println:(Ljava/lang/String;)V
  #10 = String             #14            // INSTANCE
  #11 = Methodref          #4.#42         // Singleton."<init>":(Ljava/lang/String;I)V
  #12 = Fieldref           #4.#48         // Singleton.INSTANCE:LSingleton;
  #13 = Class              #49            // java/lang/Enum
  #14 = Utf8               INSTANCE
  #15 = Utf8               LSingleton;
  #16 = Utf8               $VALUES
  #17 = Utf8               [LSingleton;
  #18 = Utf8               values
  #19 = Utf8               ()[LSingleton;
  #20 = Utf8               Code
  #21 = Utf8               LineNumberTable
  #22 = Utf8               valueOf
  #23 = Utf8               (Ljava/lang/String;)LSingleton;
  #24 = Utf8               LocalVariableTable
  #25 = Utf8               name
  #26 = Utf8               Ljava/lang/String;
  #27 = Utf8               <init>
  #28 = Utf8               (Ljava/lang/String;I)V
  #29 = Utf8               this
  #30 = Utf8               Signature
  #31 = Utf8               ()V
  #32 = Utf8               testMethod
  #33 = Utf8               <clinit>
  #34 = Utf8               Ljava/lang/Enum<LSingleton;>;
  #35 = Utf8               SourceFile
  #36 = Utf8               Singleton.java
  #37 = NameAndType        #16:#17        // $VALUES:[LSingleton;
  #38 = Class              #17            // "[LSingleton;"
  #39 = NameAndType        #50:#51        // clone:()Ljava/lang/Object;
  #40 = Utf8               Singleton
  #41 = NameAndType        #22:#52        // valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
  #42 = NameAndType        #27:#28        // "<init>":(Ljava/lang/String;I)V
  #43 = Class              #53            // java/lang/System
  #44 = NameAndType        #54:#55        // out:Ljava/io/PrintStream;
  #45 = Utf8               执行了单例类的办法
  #46 = Class              #56            // java/io/PrintStream
  #47 = NameAndType        #57:#58        // println:(Ljava/lang/String;)V
  #48 = NameAndType        #14:#15        // INSTANCE:LSingleton;
  #49 = Utf8               java/lang/Enum
  #50 = Utf8               clone
  #51 = Utf8               ()Ljava/lang/Object;
  #52 = Utf8               (Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
  #53 = Utf8               java/lang/System
  #54 = Utf8               out
  #55 = Utf8               Ljava/io/PrintStream;
  #56 = Utf8               java/io/PrintStream
  #57 = Utf8               println
  #58 = Utf8               (Ljava/lang/String;)V
{
  public static final Singleton INSTANCE; // 定义枚举项
    descriptor: LSingleton;
    flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM

  private static final Singleton[] $VALUES; // 定义对象数组，并没有初始化，只是空援用
    descriptor: [LSingleton;
    flags: ACC_PRIVATE, ACC_STATIC, ACC_FINAL, ACC_SYNTHETIC

  public static Singleton[] values();
    descriptor: ()[LSingleton;
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=0, args_size=0
         0: getstatic     #1                  // Field $VALUES:[LSingleton;
         3: invokevirtual #2                  // Method "[LSingleton;".clone:()Ljava/lang/Object;
         6: checkcast     #3                  // class "[LSingleton;"
         9: areturn
      LineNumberTable:
        line 1: 0

  public static Singleton valueOf(java.lang.String);
    descriptor: (Ljava/lang/String;)LSingleton;
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: ldc           #4                  // class Singleton
         2: aload_0
         3: invokestatic  #5                  // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
         6: checkcast     #4                  // class Singleton
         9: areturn
      LineNumberTable:
        line 1: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      10     0  name   Ljava/lang/String;

  private Singleton();
    descriptor: (Ljava/lang/String;I)V
    flags: ACC_PRIVATE
    Code:
      stack=3, locals=3, args_size=3
         0: aload_0       // 栈操作指令，把部分办法表里的第 0 个地位的变量 load 加载到栈上来，a 前缀示意它是一个援用类型。// 揭示: 当 JVM 执行一段代码的时候，首先会把用到的所有的变量存在一个本地变量表里————局部变量表。// 在栈上做计算的时候，须要应用部分办法表的值，就会通过 load 指令把它们加载到栈上来
       // 在栈上运算完之后，须要把值存回到部分办法表，所以也会有对应的 store 指令，load 和 store 是对应的。1: aload_1
         2: iload_2
         3: invokespecial #6                  // Method java/lang/Enum."<init>":(Ljava/lang/String;I)V
         6: return
      LineNumberTable:
        line 1: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       7     0  this   LSingleton;
    Signature: #31                          // ()V

  public void testMethod();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #8                  // String 执行了单例类的办法
         5: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 5: 0
        line 6: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  this   LSingleton;

  static {};
    descriptor: ()V.        // 就是代表返回 void 类型
    flags: ACC_STATIC
    Code:
      stack=4, locals=0, args_size=0
         0: new           #4                  // class Singleton
         // new #4 示意从常量池里拿到标号 4 这个类型的名字，往上看 Constant pool 局部的定义可知就是 Singleton 这个类，而后 new 进去变成对象
         3: dup          // 而后 dup 压栈
         4: ldc           #10                 // String INSTANCE, 将常量池中标号 10 的 String 类型的值 INSTANCE 推送到栈顶
         6: iconst_0        // 定义一个 int 类型的变量值为 0，我也不晓得这里定义个常量有什么卵用
         7: invokespecial #11                 // Method "<init>":(Ljava/lang/String;I)V，调用结构器初始化，返回类型为 void
        10: putstatic     #12                 // Field INSTANCE:LSingleton; 给 INSTANCE 这个动态变量赋值，和 name 一样
        13: iconst_1        // 定义一个 int 类型的变量值为 1，然并卵
        14: anewarray     #4                  // class Singleton，实例化一个装 Singleton 枚举类型的数组，这里就是 $VALUES 数组
        17: dup
        18: iconst_0
        19: getstatic     #12                 // Field INSTANCE:LSingleton; 取出字段 INSTANCE 的 name 值
        22: aastore         
        23: putstatic     #1                  // Field $VALUES:[LSingleton; 将局部变量表中的枚举项的 name 值都顺次放入 $VALUES 数组中
        26: return
      LineNumberTable:
        line 2: 0
        line 1: 13
}

实编译完的字节码是给 JVM 看的，JVM 只须要无脑程序往下执行即可。多的方面就波及 JVM 很多内容了，和本文主题无关，这里大家次要看 static 代码块中有哪些指令，明确枚举为什么会线程平安即可。

近期热文举荐：

1.1,000+ 道 Java 面试题及答案整顿(2022 最新版)

2. 劲爆！Java 协程要来了。。。

3.Spring Boot 2.x 教程，太全了！

4. 别再写满屏的爆爆爆炸类了，试试装璜器模式，这才是优雅的形式！！

5.《Java 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！