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

2023-03-22 16:06:45 分类：java 阅读()

　　本篇文章为你整理了Java 枚举实现单例模式，线程安全又优雅！（java 单例 枚举）的详细内容，包含有java枚举单例模式是性能最佳的吗 java 单例 枚举 枚举类实现单例模式 枚举单例为何能保证线程安全 Java 枚举实现单例模式，线程安全又优雅！，希望能帮助你了解 Java 枚举实现单例模式，线程安全又优雅！。

　　分享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件事

　　给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编译器优化，编译器优化常用的方法有：

　　
如果没有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开发手册（嵩山版）》最新发布，速速下载！

　　觉得不错，别忘了随手点赞+转发哦！

　　以上就是Java 枚举实现单例模式，线程安全又优雅！（java 单例 枚举）的详细内容，想要了解更多 Java 枚举实现单例模式，线程安全又优雅！的内容，请持续关注盛行IT软件开发工作室。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

标签： java

相关文章阅读

  • java Springboot集成mybatis-plus的方法是什么
  • 浅谈几种Java自定义异常处理方式
  • Java Map所有的值转为String类型
  • java代码中格式化金额 java格式化小数
  • java计算器源代码资源 java计算器简单代码
  • 【java】（一）SpringBoot 源码解析——SpringApplication 初始化（）
  • Spring学习笔记（spring教程 csdn）
  • HDFS Architecture Guide（）
  • 哈工大软件构造Lab3（2022）（哈工大软件构造lab3）
  • nginx基础（nginx基础教程）
  • Java 中HashMap详解(含HashTable, ConcurrentHashMap)（java hashmap使用方法）
  • Java 线程池之Jetty 线程池学习总结（java线程池的使用方法）
  • java线程基础（java 线程教程）
  • 聊聊 Netty 那些事儿之 Reactor 在 Netty 中的实现(创建篇)（）
  • nginx（nginx负载均衡）
    • 留言与评论（共有 条评论）
       
    验证码：