Java枚举单例模式比DCL和静态单例要好?
共 11528字,需浏览 24分钟
·
2022-05-18 16:38
你知道的越多,不知道的就越多,业余的像一棵小草!
你来,我们一起精进!你不来,我和你的竞争对手一起精进!
编辑:业余草
liuchenyang0515.blog.csdn.net
推荐:https://www.xttblog.com/?p=5340
❝饿汉式懒汉式单例就不说了,DCL和静态单例简单介绍下,为后面讲解枚举单例作铺垫。分析不易,欢迎一键三连~
❞
文章目录
双重校验锁单例 为什么要double check?去掉第二次check行不行 singleton为什么要加上volatile关键字 静态内部类单例 枚举单例 (推荐!!) 枚举单例模式的使用 反编译分析单例枚举类
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() {
}
}
枚举的写法的优点:
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);
}
}
运行结果如下:
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."":(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."":(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
#28 = Utf8 (Ljava/lang/String;I)V
#29 = Utf8 this
#30 = Utf8 Signature
#31 = Utf8 ()V
#32 = Utf8 testMethod
#33 = Utf8
#34 = Utf8 Ljava/lang/Enum;
#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 // "":(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."":(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 "":(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
代码块中有哪些指令,明白枚举为什么会线程安全即可。