点击关注公众号,实用技术文章及时了解
来源:liuchenyang0515./article/
details/121049426
文章目录
双重校验锁单例(DCL)
为什么要double check?去掉第二次check行不行?
singleton为什么要加上volatile关键字?
静态内部类单例
枚举单例 (推荐!!)
枚举单例模式的使用
反编译分析单例枚举类
1. 双重校验锁单例(DCL)
publicclassSingleton{privatestaticvolatileSingletonsingleton;privateSingleton(){}publicstaticSingletongetInstance(){if(singleton==null){synchronized(Singleton.class){if(singleton==null){singleton=newSingleton();}}}returnsingleton;}}
这种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编译器优化,编译器优化常用的方法有:
-将内存变量缓存到寄存器;
调整指令顺序充分利用CPU指令流水线,常见的是重新排序读写指令。
如果没有volatile关键字,则编译器可能优化读取,使用寄存器中的缓存值,如果这个变量由别的线程更新了的话,将出现实际值和读取的值不一致。使用了volatile后,编译器读取的时候跳过缓存,直接在内存中的实际位置读变量,写的时候通知其他缓存更新,这就是所谓的保证内存可见性,并且使用volatile还能禁止指令重排序。
publicvolatileinta=11;......intc=6;c=a;//执行这一句的时候,在高并发情况下,a如果被修改为22,那么c会被赋值为22而不是11//如果a不被volatile修饰,c有小概率被赋值为11,因为c取寄存器的缓存副本11还没来得及更新
2. 静态内部类单例
publicclassSingleton{privateSingleton(){}privatestaticclassSingletonInstance{privatestaticSingletonsingleton=newSingleton();}publicstaticSingletongetInstance(){returnSingletonInstance.singleton;}}
与饿汉式的区别就在于,类加载的时候,这里并不会实例化对象,只有调用getInstance方法才会实例化对象。
和DCL优点一样,延迟加载,效率高。
虽然DCL和静态单例都不错,但是它们并不能防止反序列化和反射生成多个实例。更好的写法当然是枚举单例了!
3. 枚举单例 (推荐!!)
其他所有的实现单例的方式其实是有问题的,那就是可能被反序列化和反射破坏。
我们来看看JDK1.5中添加的枚举类来实现单例
publicenumSingleton{INSTANCE,publicvoidtestMethod(){}}
枚举的写法的优点:
不用考虑懒加载和线程安全的问题,代码写法简洁优雅
线程安全
反编译任何一个枚举类会发现,枚举类里的各个枚举项是是通过static代码块来定义和初始化的(可以见后面3.2节反编译分析单例枚举有分析到这个),它们会在类被加载时完成初始化,而java类的加载由JVM保证线程安全,所以,创建一个Enum类型的枚举是线程安全的
防止破坏单例
我们知道,序列化可以将一个单例的实例对象写到磁盘,然后再反序列化读回来,从而获得一个新的实例。即使构造函数是私有的,反序列化时依然可以通过特殊的途径去创建类的一个新的实例,相当于调用该类的构造函数。
Java对枚举的序列化作了规定,在序列化时,仅将枚举对象的name属性输出到结果中,在反序列化时,就是通过java.lang.Enum的valueOf来根据名字查找对象,而不是新建一个新的对象。枚举在序列化和反序列化时,并不会调用构造方法,这就防止了反序列化导致的单例破坏的问题。
对于反射破坏单例的而言,枚举类有同样的防御措施,反射在通过newInstance创建对象时,会检查这个类是否是枚举类,如果是,会抛出异常java.lang.IllegalArgumentException: Cannot reflectively create enum objects
,表示反射创建对象失败。
综上,枚举可以防止反序列化和反射破坏单例。
3.1 枚举单例模式的使用
//Singleton.javapublicenumSingleton{INSTANCE;publicvoidtestMethod(){System.out.println("执行了单例类的方法");}}//Test.javapublicclassTest{publicstaticvoidmain(String[]args){//演示如何使用枚举写法的单例类Singleton.INSTANCE.testMethod();System.out.println(Singleton.INSTANCE);}}
运行结果如下:
3.2 反编译分析单例枚举类
为了让大家进一步了解枚举类,我们将上面枚举单例类进行反编译javap -p Singleton.class
,其中-p的意思是反编译的时候要包含私有方法。
//这是反编译后的内容publicfinalclassSingletonextendsjava.lang.Enum<Singleton>{publicstaticfinalSingletonINSTANCE;privatestaticfinalSingleton[]$VALUES;publicstaticSingleton[]values();publicstaticSingletonvalueOf(java.lang.String);privateSingleton();publicvoidtestMethod();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部分*/publicfinalclassSingletonextendsjava.lang.Enum<Singleton>minorversion:0majorversion:52flags:ACC_PUBLIC,ACC_FINAL,ACC_SUPER,ACC_ENUMConstantpool://需要注意常量池的部分,后面分析每条指令的时候可以回到这里查阅#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=Utf8INSTANCE#15=Utf8LSingleton;#16=Utf8$VALUES#17=Utf8[LSingleton;#18=Utf8values#19=Utf8()[LSingleton;#20=Utf8Code#21=Utf8LineNumberTable#22=Utf8valueOf#23=Utf8(Ljava/lang/String;)LSingleton;#24=Utf8LocalVariableTable#25=Utf8name#26=Utf8Ljava/lang/String;#27=Utf8<init>#28=Utf8(Ljava/lang/String;I)V#29=Utf8this#30=Utf8Signature#31=Utf8()V#32=Utf8testMethod#33=Utf8<clinit>#34=Utf8Ljava/lang/Enum<LSingleton;>;#35=Utf8SourceFile#36=Utf8Singleton.java#37=NameAndType#16:#17//$VALUES:[LSingleton;#38=Class#17//"[LSingleton;"#39=NameAndType#50:#51//clone:()Ljava/lang/Object;#40=Utf8Singleton#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=Utf8java/lang/Enum#50=Utf8clone#51=Utf8()Ljava/lang/Object;#52=Utf8(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;#53=Utf8java/lang/System#54=Utf8out#55=Utf8Ljava/io/PrintStream;#56=Utf8java/io/PrintStream#57=Utf8println#58=Utf8(Ljava/lang/String;)V{publicstaticfinalSingletonINSTANCE;//定义枚举项descriptor:LSingleton;flags:ACC_PUBLIC,ACC_STATIC,ACC_FINAL,ACC_ENUMprivatestaticfinalSingleton[]$VALUES;//定义对象数组,并没有初始化,只是空引用descriptor:[LSingleton;flags:ACC_PRIVATE,ACC_STATIC,ACC_FINAL,ACC_SYNTHETICpublicstaticSingleton[]values();descriptor:()[LSingleton;flags:ACC_PUBLIC,ACC_STATICCode:stack=1,locals=0,args_size=00:getstatic#1//Field$VALUES:[LSingleton;3:invokevirtual#2//Method"[LSingleton;".clone:()Ljava/lang/Object;6:checkcast#3//class"[LSingleton;"9:areturnLineNumberTable:line1:0publicstaticSingletonvalueOf(java.lang.String);descriptor:(Ljava/lang/String;)LSingleton;flags:ACC_PUBLIC,ACC_STATICCode:stack=2,locals=1,args_size=10:ldc#4//classSingleton2:aload_03:invokestatic#5//Methodjava/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;6:checkcast#4//classSingleton9:areturnLineNumberTable:line1:0LocalVariableTable:StartLengthSlotNameSignature0100nameLjava/lang/String;privateSingleton();descriptor:(Ljava/lang/String;I)Vflags:ACC_PRIVATECode:stack=3,locals=3,args_size=30:aload_0//栈操作指令,把局部方法表里的第0个位置的变量load加载到栈上来,a前缀表示它是一个引用类型。//提醒:当JVM执行一段代码的时候,首先会把用到的所有的变量存在一个本地变量表里————局部变量表。//在栈上做计算的时候,需要使用局部方法表的值,就会通过load指令把它们加载到栈上来//在栈上运算完之后,需要把值存回到局部方法表,所以也会有对应的store指令,load和store是对应的。1:aload_12:iload_23:invokespecial#6//Methodjava/lang/Enum."<init>":(Ljava/lang/String;I)V6:returnLineNumberTable:line1:0LocalVariableTable:StartLengthSlotNameSignature070thisLSingleton;Signature:#31//()VpublicvoidtestMethod();descriptor:()Vflags:ACC_PUBLICCode:stack=2,locals=1,args_size=10:getstatic#7//Fieldjava/lang/System.out:Ljava/io/PrintStream;3:ldc#8//String执行了单例类的方法5:invokevirtual#9//Methodjava/io/PrintStream.println:(Ljava/lang/String;)V8:returnLineNumberTable:line5:0line6:8LocalVariableTable:StartLengthSlotNameSignature090thisLSingleton;static{};descriptor:()V.//就是代表返回void类型flags:ACC_STATICCode:stack=4,locals=0,args_size=00:new#4//classSingleton//new#4表示从常量池里拿到标号4这个类型的名字,往上看Constantpool部分的定义可知就是Singleton这个类,然后new出来变成对象3:dup//然后dup压栈4:ldc#10//StringINSTANCE,将常量池中标号10的String类型的值INSTANCE推送到栈顶6:iconst_0//定义一个int类型的变量值为0,我也不知道这里定义个常量有什么卵用7:invokespecial#11//Method"<init>":(Ljava/lang/String;I)V,调用构造器初始化,返回类型为void10:putstatic#12//FieldINSTANCE:LSingleton;给INSTANCE这个静态变量赋值,和name一样13:iconst_1//定义一个int类型的变量值为1,然并卵14:anewarray#4//classSingleton,实例化一个装Singleton枚举类型的数组,这里就是$VALUES数组17:dup18:iconst_019:getstatic#12//FieldINSTANCE:LSingleton;取出字段INSTANCE的name值22:aastore23:putstatic#1//Field$VALUES:[LSingleton;将局部变量表中的枚举项的name值都依次放入$VALUES数组中26:returnLineNumberTable:line2:0line1:13}
实编译完的字节码是给JVM看的,JVM只需要无脑顺序往下执行即可。多的方面就涉及JVM很多内容了,和本文主题无关,后续会另开一篇讲字节码指令。这里大家主要看static代码块中有哪些指令,明白枚举为什么会线程安全即可。
推荐
主流Java进阶技术(学习资料分享)
Java面试题宝典
加入Spring技术开发社区
PS:因为公众号平台更改了推送规则,如果不想错过内容,记得读完点一下“在看”,加个“星标”,这样每次新文章推送才会第一时间出现在你的订阅列表里。点“在看”支持我们吧!