Java-设计模式-单例模式

单例模式

从单例加载的时机区分，有懒汉模式/饥饿模式。

从实现方式区分有双重检查模式，内部类模式/Enum模式/Map模式等。在《Effective Java》中，作者提出利用Enum时实现单例模式的最佳实践。

内容概要

1. 实现单例模式的几个关键点

2. 利用Enum实现单例模式

3. 结论

实现单例模式的几个关键点

为了实现单例模式，其核心就是确保单例对象的唯一性。需要充电关注几个关键点。

1. 无法通过new来随意创建对象，构造函数为private
2. 提供获取唯一实例对象的方法，通常是getInstance
3. 多线程并发的情况下保证维一
4. 避免反射创建单例对象（反射攻击）
5. 避免通过序列化创建单例对象（如果单例类实现了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的本质：

1. 枚举本质上是final类
2. 定义的枚举值实际上就是一个枚举类的不可变对象（比如这里的INSTALL）
3. 在Enum类加载的时候，就已经实例化了这个对象
4. 无法通过new来创建枚举对象

Enum实现单例模式的几个关键点验证

在反编译代码中，对前三个关键点已经做了明确的保证，下面看看后面两个序列化攻击和反射攻击是如何保证的。

1. 避免反射出创建单例对象（反射攻击）

   从反编译代码中，我们可以看到，枚举的私有构造函数如下所示

   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 constant's 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实例。这里的name="INSTANCE"result = 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.)** <p>Note 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 Enum<T>> T valueOf(Class<T> 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 Map<String, 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;}
}

1. 饿汉式是只要Singleton类被加载就会实例化，没有懒加载

2. 静态内部类方式是在需要实例化时，调用getInstance方法，才会加载SingletonHolder类，实例化Singleton由于类的静态属性只会在第一次加载类的时候初始化，所以在这里我们也保证了线程的安全性，所以通过这种静态内部类的方式解决了资源浪费和性能的问题