运营培训班学费大概多少,网站优化排名易下拉排名,如何在网上推广自己的公司,企业网站中文域名有必要续费吗单例模式
从单例加载的时机区分#xff0c;有懒汉模式/饥饿模式。
从实现方式区分有双重检查模式#xff0c;内部类模式/Enum模式/Map模式等。在《Effective Java》中#xff0c;作者提出利用Enum时实现单例模式的最佳实践。
内容概要 实现单例模式的几个关键点 利用Enu…单例模式
从单例加载的时机区分有懒汉模式/饥饿模式。
从实现方式区分有双重检查模式内部类模式/Enum模式/Map模式等。在《Effective Java》中作者提出利用Enum时实现单例模式的最佳实践。
内容概要 实现单例模式的几个关键点 利用Enum实现单例模式 结论
实现单例模式的几个关键点
为了实现单例模式其核心就是确保单例对象的唯一性。需要充电关注几个关键点。
无法通过new来随意创建对象构造函数为private提供获取唯一实例对象的方法通常是getInstance多线程并发的情况下保证维一避免反射创建单例对象反射攻击避免通过序列化创建单例对象如果单例类实现了Serializable
利用Enum实现单例模式
利用Enum的天然属性可以有效的保证上面的几个关键点。它属于饿汉模式的单例实现。
实现代码
Java代码
/*** 使用枚举实现单例。*/
public enum EnumSingleton {INSTANCE; // 唯一的实例对象public static EnumSingleton getInstance() {return INSTANCE;}// 单例对象的属性对象private Object obj new Object();public Object getObj() {return obj;}/*** 单例提供的对外服务。*/public Object getFactoryService() {return obj;}
}反编译代码
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3)
// Source File Name: EnumSingleton.javapackage com.ws.pattern.singleton;public final class EnumSingleton extends Enum
{public static EnumSingleton[] values(){return (EnumSingleton[])$VALUES.clone();}public static EnumSingleton valueOf(String name){return (EnumSingleton)Enum.valueOf(com/ws/pattern/singleton/EnumSingleton, name);}// 无法通过new来随意创建对象构造函数为private.private EnumSingleton(String s, int i){super(s, i);obj new Object();}// 提供获取唯一实例对象的方法通常是getInstancepublic static EnumSingleton getInstance(){return INSTANCE;}public Object getObj(){return obj;}public Object getFactoryService(){return new Object();}// 提供获取唯一实例对象的方法通常是getInstance// 也可以直接获取到INSTANCE但是获取到的都是一个对象public static final EnumSingleton INSTANCE;private Object obj;private static final EnumSingleton $VALUES[];// 静态代码中实例化对象多线程并发的情况下保证唯一属于饿汉模式static {INSTANCE new EnumSingleton(INSTANCE, 0);$VALUES (new EnumSingleton[] {INSTANCE});}
}从反编译代码中我们可以看到Enum的本质
枚举本质上是final类定义的枚举值实际上就是一个枚举类的不可变对象比如这里的INSTALL在Enum类加载的时候就已经实例化了这个对象无法通过new来创建枚举对象
Enum实现单例模式的几个关键点验证
在反编译代码中对前三个关键点已经做了明确的保证下面看看后面两个序列化攻击和反射攻击是如何保证的。 避免反射出创建单例对象反射攻击 从反编译代码中我们可以看到枚举的私有构造函数如下所示 private EnumSingleton(String s, int i);那我们来尝试利用反射创建对象 /*** 反射攻击。* 由于Enum天然的不允许反射创建实例所以可以完美的防范反射攻击。*/
private static void reflectionAttack() {System.out.println(反射攻击单例对象-----------开始);try {Constructor con EnumSingleton.class.getDeclaredConstructor(String.class, int.class);con.setAccessible(true);Object obj con.newInstance(INSTANCE, 0); // 反射新建对象以破坏单例System.out.println(obj);System.out.println(EnumSingleton.getInstance());} catch (Exception e) {e.printStackTrace();}System.out.println(反射攻击单例对象-----------结束);
}上看的代码运行后会抛出异常java.lang.IllegalArgumentException: Cannot reflectively create enum objects Exception in thread main java.lang.IllegalArgumentException: Cannot reflectively create enum objectsat java.lang.reflect.Constructor.newInstance(Constructor.java:416)at com.ws.pattern.singleton.EnumSingletonAppMain.reflectionAttack(EnumSingletonAppMain.java:43)at com.ws.pattern.singleton.EnumSingletonAppMain.main(EnumSingletonAppMain.java:9)从异常可以看出来newInstance抛出了异常。推测Java反射是不允许创建Enum对象的看看源码Constructor.java中的newInstance方法存在处理Enum类型实例化的一行判断代码if ((clazz.getModifiers() Modifier.ENUM) ! 0)满足这个条件就抛出异常。newInstance的JDK代码如下 public T newInstance(Object ... initargs)throws InstantiationException, IllegalAccessException,IllegalArgumentException, InvocationTargetException
{if (!override) {if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {Class? caller Reflection.getCallerClass();checkAccess(caller, clazz, null, modifiers);}}if ((clazz.getModifiers() Modifier.ENUM) ! 0)throw new IllegalArgumentException(Cannot reflectively create enum objects);ConstructorAccessor ca constructorAccessor; // read volatileif (ca null) {ca acquireConstructorAccessor();}SuppressWarnings(unchecked)T inst (T) ca.newInstance(initargs);return inst;
}原来反射机制不允许实例化Enum类型的对象自然挡住了反射攻击。
2.避免通过序列化创建单例对象如果单例类实现了Serializable序列化攻击
序列化对象后如果执行反序列化也可以创建一个对象。利用此机制来尝试创建一个新的Enum对象。
/*** 序列化攻击* 需要在单例类中增加read*/
private static void serializableAttack() {System.out.println(序列化攻击单例对象-----------开始);EnumSingleton singleton EnumSingleton.getInstance();System.out.println(singleton);try {ObjectOutputStream oos new ObjectOutputStream(new FileOutputStream(./EnumSingleton.out));oos.writeObject(singleton);ObjectInputStream ois new ObjectInputStream((new FileInputStream(./EnumSingleton.out)));Object obj ois.readObject(); // 这里利用反序列化创建对象System.out.println(obj);} catch (IOException e) {e.printStackTrace();} catch (ClassNotFoundException e) {e.printStackTrace();}System.out.println(序列化攻击单例对象-----------结束);
}从执行结果来看拿到了相同的对象。执行结果如下
序列化攻击单例对象-----------开始
INSTANCE
INSTANCE
序列化攻击单例对象-----------结束来撸代码吧跟踪进入ois.readObject()会进入ObjectInputStream.readObject0方法。其中会解析class的二进制根据class的文件定义分别解析不同类型的字段。重点关注case TC_ENUM:如下所示
switch (tc) {case TC_NULL:return readNull();case TC_REFERENCE:return readHandle(unshared);case TC_CLASS:return readClass(unshared);case TC_CLASSDESC:case TC_PROXYCLASSDESC:return readClassDesc(unshared);case TC_STRING:case TC_LONGSTRING:return checkResolve(readString(unshared));case TC_ARRAY:return checkResolve(readArray(unshared));case TC_ENUM:return checkResolve(readEnum(unshared));case TC_OBJECT:return checkResolve(readOrdinaryObject(unshared));case TC_EXCEPTION:IOException ex readFatalException();throw new WriteAbortedException(writing aborted, ex);case TC_BLOCKDATA:case TC_BLOCKDATALONG:if (oldMode) {bin.setBlockDataMode(true);bin.peek(); // force header readthrow new OptionalDataException(bin.currentBlockRemaining());} else {throw new StreamCorruptedException(unexpected block data);}case TC_ENDBLOCKDATA:if (oldMode) {throw new OptionalDataException(true);} else {throw new StreamCorruptedException(unexpected end of block data);}default:throw new StreamCorruptedException(String.format(invalid type code: %02X, tc));
}进入readEnum方法重点关注Enum.valueOf方法。如下所示
/*** Reads in and returns enum constant, or null if enum type is* unresolvable. Sets passHandle to enum constants assigned handle.*/
private Enum? readEnum(boolean unshared) throws IOException {if (bin.readByte() ! TC_ENUM) {throw new InternalError();}ObjectStreamClass desc readClassDesc(false);if (!desc.isEnum()) {throw new InvalidClassException(non-enum class: desc);}int enumHandle handles.assign(unshared ? unsharedMarker : null);ClassNotFoundException resolveEx desc.getResolveException();if (resolveEx ! null) {handles.markException(enumHandle, resolveEx);}String name readString(false);Enum? result null;Class? cl desc.forClass();if (cl ! null) {try {SuppressWarnings(unchecked)Enum? en Enum.valueOf((Class)cl, name); // 这里根据name和class拿到Enum实例。这里的nameINSTANCEresult en;} catch (IllegalArgumentException ex) {throw (IOException) new InvalidObjectException(enum constant name does not exist in cl).initCause(ex);}if (!unshared) {handles.setObject(enumHandle, result);}}handles.finish(enumHandle);passHandle enumHandle;return result;
}再跟进Enum.valueOf方法。代码如下 /*** Returns the enum constant of the specified enum type with the* specified name. The name must match exactly an identifier used* to declare an enum constant in this type. (Extraneous whitespace* characters are not permitted.)** pNote that for a particular enum type {code T}, the* implicitly declared {code public static T valueOf(String)}* method on that enum may be used instead of this method to map* from a name to the corresponding enum constant. All the* constants of an enum type can be obtained by calling the* implicit {code public static T[] values()} method of that* type.** param T The enum type whose constant is to be returned* param enumType the {code Class} object of the enum type from which* to return a constant* param name the name of the constant to return* return the enum constant of the specified enum type with the* specified name* throws IllegalArgumentException if the specified enum type has* no constant with the specified name, or the specified* class object does not represent an enum type* throws NullPointerException if {code enumType} or {code name}* is null* since 1.5*/public static T extends EnumT T valueOf(ClassT enumType,String name) {// 从enumConstantDirectory()中根据name获取对象T result enumType.enumConstantDirectory().get(name);if (result ! null)return result;if (name null)throw new NullPointerException(Name is null);throw new IllegalArgumentException(No enum constant enumType.getCanonicalName() . name);}enumConstantDirectory()是Class的方法其本质是从Class.java的enumConstantDirectory属性中获取。代码如下
private volatile transient MapString, T enumConstantDirectory null;也就是说Enum中定义的Enum成员值都被缓存在了这个Map中Key是成员名称比如“INSTANCE”Value就是Enum的成员对象。这样的机制天然保证了取到的Enum对象是唯一的。即使是反序列化也是一样的。
结论
经过上面的分析枚举的实现天然地支持了单例模式的特点大大降低了单例的开发难度。
1. 双重检测锁的单例模式
Java 代码
public class Singleton {//构造器私有化private Singleton() {}//Java多线程的happens-before原则主要定义多线程可见性的问题//volatile 禁止指令重排private static volatile Singleton singleton null;//所有的线程都可以不用争抢锁直接进入getSingletonpublic static Singleton getSingleton() {//看当前对象有没有被构建若是被构建了直接跳出if返回增强了性能if (singleton null) {//真正构建对象的时候才进行同步操作synchronized (Singleton.class) {//防止对象重复构建。//比如a线程已经进入了此代码但是线程b也拿到了上面的锁这样a和b都会new一个对象出来做一次判空检测是不是已经构建了if (singleton null) {//在指令层面这句话不是一个原子操作//1.分配内存//2.初始化对象//3.对象指向内存地址//真正执行的时候虚拟机为了效率可能会进行指令重排比如1、3、2//这样多线程环境下会出现问题。比如线程a执行顺序1、3、2到3的时候线程b判断 singleton null 为false//但是此时对象还未初始化因此b线程返回的对象是个未初始化的对象singleton new Singleton();}}}return singleton;}
}2. 单例模式之静态内部类
Java 代码
public class Singleton{private Singleton(){}private static class SingletonHodler{public static Singleton instance new Singleton();}public static Singleton getInstance(){return SingletonHodler.instance;}
}饿汉式是只要Singleton类被加载就会实例化没有懒加载 静态内部类方式是在需要实例化时调用getInstance方法才会加载SingletonHolder类实例化Singleton由于类的静态属性只会在第一次加载类的时候初始化所以在这里我们也保证了线程的安全性所以通过这种静态内部类的方式解决了资源浪费和性能的问题
