> 科技资讯 > 设计模式(四)----创建型模式之单例模式(二)

设计模式(四)----创建型模式之单例模式(二)

科技资讯 投稿 8900℃ 0 评论

设计模式(四)----创建型模式之单例模式(二)

1.1.3 存在的问题

1.1.3.1 问题演示

破坏单例模式：

使上面定义的单例类（Singleton）可以创建多个对象，枚举方式除外。有两种方式，分别是序列化和反射。

  • 序列化反序列化

    Singleton类：

    public class Singleton implements Serializable {
​
    //私有构造方法
    private Singleton( {}
​
    //定义一个静态内部类
    private static class SingletonHolder {
        //在内部类中声明并初始化外部类的对象
        private static final Singleton INSTANCE = new Singleton(;
    }
​
    //提供公共的访问方式
    public static Singleton getInstance( {
        return SingletonHolder.INSTANCE;
    }
​
}

    Test类：

    public class Test {
    public static void main(String[] args throws Exception {
        //往文件中写对象
        //writeObject2File(;
        //从文件中读取对象
        Singleton s1 = readObjectFromFile(;
        Singleton s2 = readObjectFromFile(;
​
        //判断两个反序列化后的对象是否是同一个对象
        System.out.println(s1 == s2;
    }
​
    private static Singleton readObjectFromFile( throws Exception {
        //创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Think\\Desktop\\a.txt";
        //第一个读取Singleton对象
        Singleton instance = (Singleton ois.readObject(;
​
        return instance;
    }
​
    public static void writeObject2File( throws Exception {
        //获取Singleton类的对象
        Singleton instance = Singleton.getInstance(;
        //创建对象输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Think\\Desktop\\a.txt";
        //将instance对象写出到文件中
        oos.writeObject(instance;
    }
}

    上面代码运行结果是false，表明序列化和反序列化已经破坏了单例设计模式。

  • 反射

    Singleton类：

    public class Singleton {
​
    //私有构造方法
    private Singleton( {}
    
    private static volatile Singleton instance;
​
    //对外提供静态方法获取该对象
    public static Singleton getInstance( {
​
        if(instance != null {
            return instance;
        }
​
        synchronized (Singleton.class {
            if(instance != null {
                return instance;
            }
            instance = new Singleton(;
            return instance;
        }
    }
}

    Test类：

    public class Test {
    public static void main(String[] args throws Exception {
        //获取Singleton类的字节码对象
        Class clazz = Singleton.class;
        //获取Singleton类的私有无参构造方法对象
        Constructor constructor = clazz.getDeclaredConstructor(;
        //取消访问检查
        constructor.setAccessible(true;
​
        //创建Singleton类的对象s1
        Singleton s1 = (Singleton constructor.newInstance(;
        //创建Singleton类的对象s2
        Singleton s2 = (Singleton constructor.newInstance(;
​
        //判断通过反射创建的两个Singleton对象是否是同一个对象
        System.out.println(s1 == s2;
    }
}

    上面代码运行结果是false，表明反射已经破坏了单例设计模式

注意：枚举方式不会出现这两个问题。

1.1.3.2 问题的解决

  • 序列化、反序列方式破坏单例模式的解决方法

    在Singleton类中添加readResolve(方法，在反序列化时被反射调用，如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新new出来的对象。

    Singleton类：

    public class Singleton implements Serializable {
​
    //私有构造方法
    private Singleton( {}
​
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton(;
    }
​
    //对外提供静态方法获取该对象
    public static Singleton getInstance( {
        return SingletonHolder.INSTANCE;
    }
    
    /**
     * 下面是为了解决序列化反序列化破解单例模式
     * 当进行反序列化时，会自动调用该方法，将该方法的返回值直接返回
     */
    private Object readResolve( {
        return SingletonHolder.INSTANCE;
    }
}

    Test类

    public class Client {
    public static void main(String[] args throws Exception {
        //writeObject2File(;
        readObjectFromFile(;
        readObjectFromFile(;
    }
​
    //从文件读取数据（对象）
    public static void readObjectFromFile( throws Exception {
        //1,创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Think\\Desktop\\a.txt";
        //2,读取对象
        Singleton instance = (Singleton ois.readObject(;
​
        System.out.println(instance;
​
        //释放资源
        ois.close(;
    }
​
    //向文件中写数据（对象）
    public static void writeObject2File( throws Exception {
        //1,获取Singleton对象
        Singleton instance = Singleton.getInstance(;
        //2,创建对象输出流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Think\\Desktop\\a.txt";
        //3,写对象
        oos.writeObject(instance;
        //4,释放资源
        oos.close(;
    }
}

    可以看到打印出来的两个地址是一样的，说明已经解决单例模式被破坏的问题

    那为啥会自动调用readResolve这个方法呢？实际上就是ObjectInputStream种的readObject方法在起作用

    源码解析：

    ObjectInputStream类

    public final Object readObject( throws IOException, ClassNotFoundException{
    ...
    // if nested read, passHandle contains handle of enclosing object
    int outerHandle = passHandle;
    try {
        Object obj = readObject0(false;//重点查看readObject0方法
    .....
}
    
private Object readObject0(boolean unshared throws IOException {
    ...
    try {
        switch (tc {
            ...
            case TC_OBJECT:
                return checkResolve(readOrdinaryObject(unshared;//重点查看readOrdinaryObject方法
            ...
        }
    } finally {
        depth--;
        bin.setBlockDataMode(oldMode;
    }    
}
    
private Object readOrdinaryObject(boolean unshared throws IOException {
    ...
    //isInstantiable 返回true，执行 desc.newInstance(，通过反射创建新的单例类，
    obj = desc.isInstantiable( ? desc.newInstance( : null; 
    ...
    // 在Singleton类中添加 readResolve 方法后 desc.hasReadResolveMethod( 方法执行结果为true
    if (obj != null && handles.lookupException(passHandle == null && desc.hasReadResolveMethod( {
        // 通过反射调用 Singleton 类中的 readResolve 方法，将返回值赋值给rep变量
        // 这样多次调用ObjectInputStream类中的readObject方法，继而就会调用我们定义的readResolve方法，所以返回的是同一个对象。
        Object rep = desc.invokeReadResolve(obj;
        ...
    }
    return obj;
}

  • 反射方式破解单例的解决方法

    public class Singleton {
​
    private static boolean flag = false;
​
    //私有构造方法
    private Singleton( {
        synchronized (Singleton.class {
​
            //判断flag的值是否是true，如果是true，说明非第一次访问，直接抛一个异常，如果是false的话，说明第一次访问
            if (flag {
                throw new RuntimeException("不能创建多个对象";
            }
            //将flag的值设置为true
            flag = true;
        }
    }
​
    //定义一个静态内部类
    private static class SingletonHolder {
        //在内部类中声明并初始化外部类的对象
        private static final Singleton INSTANCE = new Singleton(;
    }
​
    //提供公共的访问方式
    public static Singleton getInstance( {
        return SingletonHolder.INSTANCE;
    }
}
​

说明:

这种方式比较好理解。当通过反射方式调用构造方法进行创建创建时，直接抛异常。不运行此中操作。

接下来介绍一个在jdk中源码中使用单例模式的一个类

1.1.4 JDK源码解析-Runtime类

Runtime类就是使用的单例设计模式。

  1. 通过源代码查看使用的是哪儿种单例模式

    public class Runtime {
    private static Runtime currentRuntime = new Runtime(;
​
    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime( {
        return currentRuntime;
    }
​
    /** Don't let anyone else instantiate this class */
    private Runtime( {}
    ...
}

    从上面源代码中可以看出Runtime类使用的是饿汉式（静态属性）方式来实现单例模式的。

  2. 使用Runtime类中的方法

    public class RuntimeDemo {
    public static void main(String[] args throws IOException {
        //获取Runtime类对象
        Runtime runtime = Runtime.getRuntime(;
​
        //返回 Java 虚拟机中的内存总量。
        System.out.println(runtime.totalMemory(;
        //返回 Java 虚拟机试图使用的最大内存量。
        System.out.println(runtime.maxMemory(;
​
        //创建一个新的进程执行指定的字符串命令，返回进程对象
        Process process = runtime.exec("ipconfig";
        //获取命令执行后的结果，通过输入流获取
        InputStream inputStream = process.getInputStream(;
        byte[] arr = new byte[1024 * 1024* 100];
        int b = inputStream.read(arr;
        System.out.println(new String(arr,0,b,"gbk";
    }
}

执行结果如下

  

 

 

编程笔记 » 设计模式(四)----创建型模式之单例模式(二)

赞同 (47) or 分享 (0)
游客 发表我的评论   换个身份
取消评论

表情
(0)个小伙伴在吐槽