传统的单例写法解决了什么问题
首先，在大多数情况下(不包含面试)，传统的单例写法已经完全够用了。通过 synchronized 关键字解决了多线程并发使用。
|
1 2 3 4 5 6 |
public synchronized static SingleClassV1 getInstance(){ if (instance == null ){ instance = new SingleClassV1(); } return instance; } |
考虑到每次获取单例对象都需要加锁，解锁。又有人发明了双重锁校验 + volatile 关键字模式：
|
1 2 3 4 5 6 7 8 9 10 11 |
private static volatile SingleClassV2 instance; public static SingletonV2 getInstance() { if (instance == null ){ synchronized (SingletonV2. class ){ if (instance == null ){ instance = new SingletonV2(); } } } return instance; } |
另外一种为了解决单例被重复初始化的写法：利用类只会被初始化一次的特性，又有人发明出来一种内部类单例的写法。
|
1 2 3 4 5 6 |
private static class SingletonHolder { private static final SingletonV3 INSTANCE = new SingletonV3(); } public static final SingletonV3 getInstance() { return SingletonHolder.INSTANCE; } |
仍然存在的问题
由于 java 中有反射 API 这种变态的存在，以上所有的私有构造方法在反射面前都是毛毛雨。
|
1 2 3 4 |
Class<?> clazzV2 = Class.forName(SingleClassV2. class .getName()); Constructor<?> constructor = clazzV2.getDeclaredConstructors()[ 0 ]; constructor.setAccessible( true ); Object o = constructor.newInstance(); |
看来私有方法是防君子不防小人
为什么枚举就没有问题
我们来先看一下基于枚举的单例是什么样的。
|
1 2 3 4 5 6 |
public enum SingleClassV4 { INSTANCE; public String doSomeThing(){ return "hello world" ; } } |
当然，从 java 代码是看不出来任何端倪的。再使用 javap 看一下字节码。
|
1 2 3 4 |
public final class git.frank.SingleClassV4 extends java.lang.Enum<git.frank.SingleClassV4> minor version: 0 major version: 52 flags: ACC_PUBLIC, ACC_FINAL, ACC_SUPER, ACC_ENUM |
可以发现，枚举类型会帮我们自动继承 java.lang.Enum 类。并且，在 flags 中该类被添加了 ACC_ENUM 标识。然后，再看一下枚举类的构造方法：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
private git.frank.SingleClassV4(); descriptor: (Ljava/lang/String;I)V flags: ACC_PRIVATE Code: stack= 3 , locals= 3 , args_size= 3 0 : aload_0 1 : aload_1 2 : iload_2 3 : invokespecial # 6 // Method java/lang/Enum."<init>":(Ljava/lang/String;I)V 6 : return LineNumberTable: line 3 : 0 //加入Java开发交流君样：756584822一起吹水聊天 LocalVariableTable: Start Length Slot Name Signature 0 7 0 this Lgit/frank/SingleClassV4; Signature: # 29 // ()V |
枚举类也是要有构造方法的，而且也和普通的类没什么不同，也一样可以通过反射获取到：
接下来，让我们通过反射 invoke 一下他的构造方法看看会发生什么：
|
1 |
constructor.newInstance(); |
结果如下：
Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
通过看 newInstance 方法代码的话，就很容易知道原因了：
|
1 2 3 4 5 6 7 8 9 10 11 |
public T newInstance(Object ... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { //加入Java开发交流君样：756584822一起吹水聊天 ... if ((clazz.getModifiers() & Modifier.ENUM) != 0 ) throw new IllegalArgumentException( "Cannot reflectively create enum objects" ); ... T inst = (T) ca.newInstance(initargs); return inst; } |
java 的反射 API 在创建对象实例是判断了当前类是否是枚举类型，否则就抛异常出来。
总结
在传统的单例写法中，由于私有构造方法并不能完全杜绝从外部创建实例，所以严格来说那些单例的实现方式是存在漏洞的。
由于 java 的反射 API 已经通过写死的方式限制了不能为枚举类型创建实例，所以… 也算了解决了吧。哎呀，这个东西是也是面试被问到的，正常人谁会用反射这种外挂去突破单例。
本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注的更多内容！
原文链接：https://blog.csdn.net/wj1314250/article/details/117260150
查看更多关于一篇文章教你使用枚举来实现java单例模式的详细内容...