前言
如果看到标题就能表示赞同的小伙伴,那估摸你也肯定看过Joshua Bloch
大神说过的这么一句话:单元素的枚举类型已经成为实现Singleton的最佳方法
。我把它翻译成人话就是:实现单例模式的最佳方法是使用枚举。
单例模式
单例模式(Singleton Pattern):确保一个类有且只有
一个实例,并提供一个全局访问点。
在开发中,很多时候有一些对象其实我们只需要一个,例如:线程池(threadpool)
、缓存(cache)
、默认设置
、注册表(registry)
、日志对象
等等,这个时候把它设计为单例模式是最好的选择。
Java中单例模式是一种广泛使用的设计模式,单例模式有很多好处,它能够避免实例对象的重复创建,不仅可以减少每次创建对象的时间开销,还可以节约内存空间(比如spring管理的无状态bean);还能够避免由于操作多个实例导致的逻辑错误。如果一个对象有可能贯穿整个应用程序,而且起到了全局统一管理控制的作用,那么单例模式也许是一个值得考虑的选择。
单例模式7种写法
单例模式的写法非常多,但很多写法存在一些不足,下面以示例的方式加以指出:
1、懒汉(线程不安全):
public class Singleton {
private static Singleton instance;
private Singleton (){} //私有构造函数
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
复制
这种写法lazy loading(懒加载)很明显,但是一看就知道,存在线程安全问题,所以这种写法是被禁止的。
2、懒汉(线程安全):
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
复制
显然加了个synchronized来保证线程安全,but,效率太低了,毕竟99.99%的情况下是不需要同步的,有点用力过猛。极力不推荐使用
3、饿汉:
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
复制
这种基于classloder机制避免了多线程的同步问题,初始化的时候就给装载了。但是现在,没有懒加载的效果了。这是最简单的一种实现,据我了解绝大部分小伙伴都是这些写单例模式的~
4、饿汉(变种):
public class Singleton {
private static Singleton instance = null;
static {
instance = new Singleton();
}
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
复制
和上面差不多,都是在本类初始化即实例化instance。
5、静态内部类:
public class Singleton {
// 静态内部类
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
复制
请注意这种方式和上面是存在不一样的地方的 。
据我了解:面试中能答出这种方式以及下面方式,都属加分项
刚分析了方式3、4都没有lazy loading效果
。而这种方式Singleton类
被装载了,instance
不会被立马初始化,因为SingletonHolder类
没有被主动使用,只有显示通过调用getInstance
方法时,才会显示装载SingletonHolder类,显然它达到了`lazy loading效果
6、双重校验锁(懒汉)
public class Singleton {
private volatile static Singleton singleton;
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
// 注意此处还得有次判空~
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
复制
使用到了volatile机制。这个是第二种方式的升级版,俗称双重检查锁定。既保证了效率,又保证了安全。代码稍微复杂点,但显得比较高级~
7、枚举
public enum Singleton {
INSTANCE;
}
复制
使用枚举方式实现,也是本文的主菜。
这种方式是Effective Java
作者Josh Bloch
提倡的方式,它不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象,可谓是很坚强的壁垒啊。 所以这种写法,是十分推荐的且是最优的
为何枚举方式
是最好的单例实现方式?
前几种方式实现单例都有如下3个特点:
- 构造方法私有化
- 实例化的变量引用私有化
- 获取实例的方法共有
这种实现方式的问题就在低一点:私有化构造器并不保险
。因为它抵御不了反射攻击
,比如如下示例代码:
以大家最为常用的
饿汉式
为例,看我怎么攻击它
public class Singleton implements Serializable {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
public class Main {
public static void main(String[] args) throws Exception {
Singleton s = Singleton.getInstance();
// 拿到所有的构造函数,包括非public的
Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
constructor.setAccessible(true);
// 使用空构造函数new一个实例。即使它是private的~~~
Singleton sReflection = constructor.newInstance();
System.out.println(s); //com.fsx.bean.Singleton@1f32e575
System.out.println(sReflection); //com.fsx.bean.Singleton@279f2327
System.out.println(s == sReflection); // false
}
}
复制
运行输出:
com.fsx.bean.Singleton@1f32e575
com.fsx.bean.Singleton@279f2327
false
复制
通过反射,竟然给所谓的单例创建出了一个新的实例对象。所以这种方式也还是存在不安全因素的。怎么破???如何解决??? 其实Joshua Bloch
说了:可以在构造函数在被第二次调用的时候抛出异常。具体示例代码,可以参考枚举实现的源码,哈哈。
再看看它的序列化、反序列时会不会有问题。如下:
注意:JDK的序列化、反序列化底层并不是反射~~~
public class Main {
public static void main(String[] args) throws Exception {
Singleton s = Singleton.getInstance();
byte[] serialize = SerializationUtils.serialize(s);
Object deserialize = SerializationUtils.deserialize(serialize);
System.out.println(s);
System.out.println(deserialize);
System.out.println(s == deserialize);
}
}
复制
运行结果:
com.fsx.bean.Singleton@452b3a41
com.fsx.bean.Singleton@6193b845
false
复制
可以看出,序列化前后两个对象并不相等。所以它序列化也是不安全的
下面看看枚举大法
使用枚举实现单例极其的简单:
public enum EnumSingleton {
INSTANCE;
}
复制
首先看看是否防御反射攻击:
public class Main {
public static void main(String[] args) throws Exception {
EnumSingleton s = EnumSingleton.INSTANCE;
// 拿到所有的构造函数,包括非public的
Constructor<EnumSingleton> constructor = EnumSingleton.class.getDeclaredConstructor();
constructor.setAccessible(true);
// 使用空构造函数new一个实例。即使它是private的~~~
EnumSingleton sReflection = constructor.newInstance();
System.out.println(s); //com.fsx.bean.Singleton@1f32e575
System.out.println(sReflection); //com.fsx.bean.Singleton@279f2327
System.out.println(s == sReflection); // false
}
}
复制
结果运行就报错:
Exception in thread "main" java.lang.NoSuchMethodException: com.fsx.bean.EnumSingleton.<init>()
at java.lang.Class.getConstructor0(Class.java:3082)
at java.lang.Class.getDeclaredConstructor(Class.java:2178)
at com.fsx.maintest.Main.main(Main.java:19)
复制
这个看起来是因为没有空的构造函数导致的,还并不能下定义说防御了反射攻击。那它有什么构造函数呢,可以看它的父类Enum类:
// @since 1.5 它是所有Enum类的父类,是个抽象类
public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {
// 这是它的唯一构造函数,接收两个参数(若没有自己额外指定构造函数的话~)
protected Enum(String name, int ordinal) {
this.name = name;
this.ordinal = ordinal;
}
...
}
复制
既然它有这个构造函数,那我们就先拿到这个构造函数再创建对象试试:
public class Main {
public static void main(String[] args) throws Exception {
EnumSingleton s = EnumSingleton.INSTANCE;
// 拿到所有的构造函数,包括非public的
Constructor<EnumSingleton> constructor = EnumSingleton.class.getDeclaredConstructor(String.class, int.class);// 拿到有参的构造器
constructor.setAccessible(true);
// 使用空构造函数new一个实例。即使它是private的~~~
System.out.println("拿到了构造器:" + constructor);
EnumSingleton sReflection = constructor.newInstance("testInstance", 1);
System.out.println(s); //com.fsx.bean.Singleton@1f32e575
System.out.println(sReflection); //com.fsx.bean.Singleton@279f2327
System.out.println(s == sReflection); // false
}
}
复制
运行打印:
拿到了构造器:private com.fsx.bean.EnumSingleton(java.lang.String,int)
Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
at com.fsx.maintest.Main.main(Main.java:22)
复制
第一句输出了,表示我们是成功拿到了构造器Constructor
对象的,只是在执行newInstance
时候报错了。并且也提示报错在Constructor
的417行,看看Constructor
的源码处:
public final class Constructor<T> extends Executable {
...
public T newInstance(Object ... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
...
if ((clazz.getModifiers() & Modifier.ENUM) != 0)
throw new IllegalArgumentException("Cannot reflectively create enum objects");
...
}
...
}
复制
主要是这一句:(clazz.getModifiers() & Modifier.ENUM) != 0
。说明:反射在通过newInstance创建对象时,会检查该类**是否ENUM修饰**,如果是则抛出异常,反射失败
,因此枚举类型对反射是绝对安全的。
那么,枚举对序列化、反序列化是否安全?
public class Main {
public static void main(String[] args) {
EnumSingleton s = EnumSingleton.INSTANCE;
byte[] serialize = SerializationUtils.serialize(s);
Object deserialize = SerializationUtils.deserialize(serialize);
System.out.println(s == deserialize); //true
}
}
复制
结果是:true
。因此:枚举类型对序列化、反序列也是安全的。
综上,可以得出结论:枚举是实现单例模式的最佳实践。毕竟使用它全都是优点:
- 反射安全
- 序列化/反序列化安全
- 写法简单
- 没有一个更有信服力的原因不去使用枚举
附:局变量比单例模式差在哪里?
- 不可延迟实例化
- 不能保证全局只有一个实例(因为使用者都可以自己new对象)
总结
单例模式作为最为简单的一种设计模式,可以说是用到了everywhere
,它不仅仅是我们撸码中肯定会用到的,更是面必问
的一道题。我相信你理解了本文之后,以后不管使用和面试,都能轻松应对~
转自:Java单例模式的7种写法中,为何用Enum枚举实现被认为是最好的方式?【享学Java】 - 腾讯云开发者社区-腾讯云