Java枚举单例模式比DCL和静态单例要好？———反编译分析单例枚举类-天翼云

文章目录

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

1.1 为什么要double check？去掉第二次check行不行？
1.2 singleton为什么要加上volatile关键字?

2. 静态内部类单例
3. 枚举单例 (推荐！！)

3.1 枚举单例模式的使用
3.2 反编译分析单例枚举类

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() {
		
	}
}

枚举的写法的优点：

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

反编译任何一个枚举类会发现，枚举类里的各个枚举项是是通过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
  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代码块中有哪些指令，明白枚举为什么会线程安全即可。

活动

应用商城

合作伙伴

开发者

支持与服务

了解天翼云

Java枚举单例模式比DCL和静态单例要好？———反编译分析单例枚举类

Java枚举单例模式比DCL和静态单例要好？———反编译分析单例枚举类

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

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

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

2. 静态内部类单例

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

3.1 枚举单例模式的使用

3.2 反编译分析单例枚举类

相关文章

SQLite3数据库的安装与使用教程

java大文件下载浏览器内存溢出

Java中的泛型编程：高级用法与技巧

探索Java中的依赖注入与控制反转

使用Apache Spark进行Java数据分析

如何在Java中实现并发控制与锁机制

使用Akka构建分布式Java应用程序

使用Java构建高可用性的系统架构

Java中的ReentrantLock详解

深入理解Java中的类加载机制

作者介绍

最新文章

SQLite3数据库的安装与使用教程

java大文件下载浏览器内存溢出

Java中的泛型编程：高级用法与技巧

使用Apache Spark进行Java数据分析

探索Java中的依赖注入与控制反转

Java中的ReentrantLock详解

热门文章

Java线程同步synchronized wait notifyAll

Android/Java判断字符串String是否为float浮点数或double类型

Java/Android Annotation注解/注入（二）

Java小数点数字和百分号数字之间的转换

Java switch case语句

Java新AIO/NIO2：AsynchronousFileChannel以Future方式读

热门标签

相关产品

弹性云主机

天翼云电脑（公众版）

对象存储

云硬盘

随机文章

第二十章《Java Swing》第4节：事件处理与监听器

Java：String类再回顾

深入理解Java中的泛型编程

数据结构之堆栈的链式存储（Java表示）

Java中的数据验证与输入校验策略

android学习笔记----关于findViewById那些事