首页 > 其他分享 >设计模式(四)----创建型模式之单例模式（二）

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

时间：2023-02-04 19:56:07浏览次数：53  
标签：Singleton 模式 ---- instance static private new 设计模式 public

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

执行结果如下

  

 

 

标签：Singleton,模式,----,instance,static,private,new,设计模式,public
From： https://www.cnblogs.com/xiaoyh/p/16557833.html

相关文章

  • PyQt5按钮点击信号clicked报错
    提问： 我把python文件包移动到了e盘，然后编辑器connect就报黄色了。重装了pythonpyqt5编辑器，现在编辑器没有黄色，但是：本机QT信号不可调用。用之前写的代码运行不报错，现在......
  • 固板改造
    承接上文https://www.cnblogs.com/wandia/p/17084881.html为了达到使用WrapPanel作为布局面板时候实现查询按钮靠右，又瞎搞了WrapPanel,实现效果如下图，由于代码有Bug，请留......
  • 《剑指Offer》-5-替换空格
    因为C++中的string本质上是一个静态数组，所以不能直接将长度1的空格直接替换为长度3的指定字符串也就是说要准备一个新的字符串才行 stringreplaceSpace(string......
  • CSharp: donet 6 create view with EF Core 6
     [Keyless]publicclassPersonOrderCount{publicstringName{get;set;}publicintCount{get;set;}}publicclassPerson{publicintPe......
  • 力扣-138-复杂链表的复制/剑指Offer-35-复杂链表的复制
    与复制普通链表的区别在于：多出了一个随机指针我们考虑下复制一个普通链表：遍历并复制节点i，让构造的他的上一个节点指向i看起来只需要2个指针，指针1指向当前构造的节点，指......
  • 分组排名（Power Query）
    数据源：//分组美式排名let源=Excel.CurrentWorkbook(){[Name="表1"]}[Content],分表=Table.Group(源,"班级",{"分表",eachTable.AddRankColumn(_,"排......
  • 降低vue/cli版本，从5.0.8换到4.4.6
    由于之前装了最新版的vue/cli，最新版的脚手架用的是vue3，不仅要重新学vue3的语法，而且elementui也用不了，用element-plus，等价于--->本人不会！因此今天换vue脚手架的版本，等以后有......
  • vuejs从入门到精通——计算属性缓存 vs 方法
    计算属性缓存vs方法https://cn.vuejs.org/guide/essentials/computed.html#basic-exampletemplate:<p>{{calculateBooksMessage()}}</p>js://组件中fun......
  • 指针类型分析
    /*指针类型分析*/#include<stdlib.h>#include<string.h>#include<stdio.h>#include<errno.h>#include<assert.h>voidtest(){constchar*p1="worl......
  • 论文阅读： CCF A（ICSE） 2022 MVD: 基于流敏感图神经网络的内存相关漏洞检测
    Abstract：内存相关漏洞对现代软件的安全构成了严重威胁。尽管基于深度学习的方法在一般性漏洞检测方面取得了成功，但在应用于内存相关漏洞检测时，仍然受到流信息利用不......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99