懵了,Java枚举单例模式比DCL和静态单例要好???

>>强大,10k+点赞的 SpringBoot 后台管理系统竟然出了详细教程!

点击关注公众号,实用技术文章及时了解懵了,Java枚举单例模式比DCL和静态单例要好???

来源:liuchenyang0515.blog.csdn.net/article/

details/121049426

文章目录

  1. 双重校验锁单例(DCL)
    • 为什么要double check?去掉第二次check行不行?
    • singleton为什么要加上volatile关键字?
  2. 静态内部类单例
  3. 枚举单例 (推荐!!)
    • 枚举单例模式的使用
    • 反编译分析单例枚举类

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,我们看看会出现什么问题

懵了,Java枚举单例模式比DCL和静态单例要好???

虽然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);
    }
}

运行结果如下:

懵了,Java枚举单例模式比DCL和静态单例要好???

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
  flagsACC_PUBLICACC_FINALACC_SUPERACC_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 10

  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 10
      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
         6return
      LineNumberTable:
        line 10
      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
         8return
      LineNumberTable:
        line 50
        line 68
      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
         0new           #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数组中
        26return
      LineNumberTable:
        line 20
        line 113
}

实编译完的字节码是给JVM看的,JVM只需要无脑顺序往下执行即可。多的方面就涉及JVM很多内容了,和本文主题无关,后续会另开一篇讲字节码指令。这里大家主要看static代码块中有哪些指令,明白枚举为什么会线程安全即可。

推荐

主流Java进阶技术(学习资料分享)

Java面试题宝典

加入Spring技术开发社区

懵了,Java枚举单例模式比DCL和静态单例要好???

PS:因为公众号平台更改了推送规则,如果不想错过内容,记得读完点一下“在看”,加个“星标”,这样每次新文章推送才会第一时间出现在你的订阅列表里。“在看”支持我们吧!

原文始发于微信公众号(Java知音):懵了,Java枚举单例模式比DCL和静态单例要好???