单例模式的应用(3)

为什么写了readResolve方法,反序列化就不会破坏单例呢?原因如下:

ObjectInputStream的readOrdinaryObject(boolean unshared)方法


   private Object readOrdinaryObject(boolean unshared)
        throws IOException
    {
        if (bin.readByte() != TC_OBJECT) {
            throw new InternalError();
        }

        ObjectStreamClass desc = readClassDesc(false);
        desc.checkDeserialize();

        Class<?> cl = desc.forClass();
        if (cl == String.class || cl == Class.class
                || cl == ObjectStreamClass.class) {
            throw new InvalidClassException("invalid class descriptor");
        }

        Object obj;
        try {
            obj = desc.isInstantiable() ? desc.newInstance() : null;
        } catch (Exception ex) {
            throw (IOException) new InvalidClassException(
                desc.forClass().getName(),
                "unable to create instance").initCause(ex);
        }

        passHandle = handles.assign(unshared ? unsharedMarker : obj);
        ClassNotFoundException resolveEx = desc.getResolveException();
        if (resolveEx != null) {
            handles.markException(passHandle, resolveEx);
        }

        if (desc.isExternalizable()) {
            readExternalData((Externalizable) obj, desc);
        } else {
            readSerialData(obj, desc);
        }

        handles.finish(passHandle);
        //重点:这里的意思就是:如果有写readResolve方法,就调用readResovle方法
        if (obj != null &&
            handles.lookupException(passHandle) == null &&
            desc.hasReadResolveMethod())
        {
            //反射调用ReadResolve方法
            Object rep = desc.invokeReadResolve(obj);
            if (unshared && rep.getClass().isArray()) {
                rep = cloneArray(rep);
            }
            if (rep != obj) {
                handles.setObject(passHandle, obj = rep);
            }
        }

        return obj;
    }


看到上面应该很清楚了,在条件判断中 desc.hasReadResolveMethod()会判断是否有readResolve()方法,如果有的话会通过desc.invokeReadResolve(obj)去反射调用该方法,返回的就是同一个对象。


教你破坏单例模式


序列化破坏单例&反射破坏单例


通过JDK源码分析我们可以看出,虽然增加了readResolver()方法返回实例解决了单例模式别破坏的问题,但是实际上实例化了两次,只不过新创建的对象并没有被返回而已。如果创建对象的动作发生频率加快,就意味着内存分配开销也会随之增大。于是引入了 下边注册时的单例模式。


五、注册式单例模式

注册式单例模式又称为登记式单例模式,就是将每一个实例都登记到某一个地方,使用唯一的标识,注册式单例模式有两种:一种为枚举式单例模式,另一种为容器式单例模式。

1、枚举式单例模式


public enum EnumSingleton {
    INSTANCE;

    private Object data;

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public static EnumSingleton getInstance(){return INSTANCE;}
}


枚举式单例能够防止序列化破坏单例

使用非常好用的反编译工具Jad,解压之后配置好环境变量,就可以使用命令行调用了。找到工程所在Class目录,复制EnumSingleton.class所在的路径。

然后切换命令行,切换到工程所在的Class目录,输入命令jad并在后面输入复制好的路径,在Class目录下边会多出一个EnumSingleton.jad文件。打开EnumSingleton.jad文件,我们惊奇的发现有如下代码:


staic 
{
    INSTANCE = new EnumSingleton("INSTANCE",0);
    $VALUES  = (new EnumSingletion[]{
          INSTANCE
    });
}


原来,枚举类单例模式在静态代码块中就给INSTANCE进行了复制,是饿汉式单例模式的实现。

至此,我们还可以试想,序列化能否破坏枚举式单例模式呢?


private Object readObject0(){
   ...
   case TC_ENUM:
      return checkResolve(readEnum(unshared));
   ...
}


我们看到,在readObject0()中调用了readEnum()方法,来看readEnum()方法的代码实现:


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);
                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;
    }


枚举式单例能够防止反射破坏单例

枚举式单例在初始化的时候使用静态代码块,饿汉式;在初始化实例的时候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);
            }
        }
        //JDK中的判断,如果是枚举,就无法生成实例 
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;   // read volatile
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        @SuppressWarnings("unchecked")
        T inst = (T) ca.newInstance(initargs);
        return inst;
    }


从上述代码可以看出,在newInstance()方法中做了强制性判断,如果修饰符Modifier.ENUM枚举类型,则直接抛出异常。这个地方和静态内部类的处理方式有异曲同工之妙。对,但是我们自己在构造方法中写逻辑处理可能存在未知的风险,而JDK的处理是最官方、最权威、最稳定的。因为枚举式单例模式也是《Effective Java》书中推荐的一种单例模式实现写法。


六、


四、静态内部类


2.容器式单例

其实枚举式单例,虽然写法优雅,但是也会有一些问题。因为它在类加载之时就将所有的对象初始化放在类内存中,这其实和饿汉式并无差异,不适合大量创建单例对象的场景。那么接下来看注册式 单例模式的另一种写法,即容器式单例模式,创建ContainerSingleton类


public class ContainerSingleton {

    private ContainerSingleton(){}

    private static Map<String,Object> ioc = new ConcurrentHashMap<String, Object>();

    public static Object getInstance(String className){
        Object instance = null;
        if(!ioc.containsKey(className)){
            try {
                instance = Class.forName(className).newInstance();
                ioc.put(className, instance);
            }catch (Exception e){
                e.printStackTrace();
            }
            return instance;
        }else{
            return ioc.get(className);
        }
    }

}


容器式单例模式适用于需要大量创建单例对象的场景,便于管理。但是它是非线程安全的。到此,

注册式单例模式介绍完毕。我们再来看看Spring中的容器式单例模式的实现代码:

六、ThreadLocal单例模式


package nju.java.pattern.singleton_pattern;
 
/**
 * 线程单例实现ThreadLocal
 * ThreadLocal 保证其创建的对象是全局唯一的,
 * 但是能保证在单个线程中是唯一的,天生是线程安全的
 */
public class ThreadLocalSingleton {
    public static final ThreadLocal<ThreadLocalSingleton> threadLocalInstance=
            new ThreadLocal<ThreadLocalSingleton>(){
                @Override
                protected ThreadLocalSingleton initialValue(){
                    return new ThreadLocalSingleton();
                }
            };
    private ThreadLocalSingleton(){}
 
    public static ThreadLocalSingleton getInstance(){
        return threadLocalInstance.get();
    }
}
上一篇:利用物联网操作系统Zephyr实现“连续集成”开源软件的开发


下一篇:Flex与.NET互操作(八):使用FluorineFx网关实现远程访问