单例设计模式

单例模式

概念:

在应用程序中保证有且只有一个实例

1.懒汉式

java 复制代码
public class Single implements Serializable {
    private static final long serialVersionUID = 1L;
    
    private static Single single;
    
    private static volatile boolean flag = false;
    
    private Single() {
        
        /** 防止反射多线程调用 */
        synchronized(Single.class) {
            /**
            * 防止反射破坏单例模式
            * 若flag为true,表示已经通过构造器创建过实例,则抛出异常,为false则正常创建实例。
            */
            if (flag) {
        	     throw new RuntimeException("不可重复创建Single实例");
            }
            flag = true;
        }
    }
    
    public static Single getInstance(){
        if (this.single == null) {
            // 使用同步锁,防止多线程下创建多个对象
            synchronized (Single.class) {
                // 双重校验
                if (this.single == null){
                    single = new Single();
                }
            }
        }
        return single;
    }
    
    /**
    * 防止反序列化破坏单例模式(为什么要创建readResolve方法,具体看源码)(如果类未实现Serializable接口,该方法可以忽略)
    */
    public Object readResolve() {
        return single;
    }
}

总结:

1.懒汉式是在第一次使用实例的时候去创建实例,创建完后会一直存在,直到系统停止;

2.显性创建实例,多线程下线程不安全(多线程下使用synchronized和双重锁来解决线程安全)。

2.饿汉式(静态变量)

java 复制代码
public class Single implements Serializable {
    private static final long serialVersionUID = 1L;
    
    /** 在加载Single类的时候创建instance变量(系统启动时会加载类) */
    private static final Single INSTANCE = new Single();
    
    private static volatile boolean flag = false;
    
    /** 私有化构造器 */
    private Single(){
        
        /** 防止反射多线程调用 */
        synchronized(Single.class) {
            /**
            * 防止反射破坏单例模式
            * 若flag为true,表示已经通过构造器创建过实例,则抛出异常,为false则正常创建实例。
            */
            if (flag) {
        	     throw new RuntimeException("不可重复创建Single实例");
            }
            flag = true;
        }
    }
    
    /** 对外提供获取实例的方法 */
    public static Single getInstance(){
        return INSTANCE;
    }
    
    /**
    * 防止反序列化破坏单例模式
    */
    public Object readResolve() {
        return INSTANCE;
    }
}

3.饿汉式(静态代码块)

java 复制代码
public class Single implements Serializable {
    private static final long serialVersionUID = 1L;
    
    private static final Single INSTANCE;
    
    private static volatile boolean flag = false;
    
    static {
    	INSTANCE = new Single();
    }
    
    private Single() {

        /** 防止反射多线程调用 */
        synchronized(Single.class) {
            /**
            * 防止反射破坏单例模式
            * 若flag为true,表示已经通过构造器创建过实例,则抛出异常,为false则正常创建实例。
            */
            if (flag) {
        	     throw new RuntimeException("不可重复创建Single实例");
            }
            flag = true;
        }  
    }
    
    /** 对外提供获取实例的方法 */
    public static Single getInstance(){
        return INSTANCE;
    }
    
    /**
    * 防止反序列化破坏单例模式(为什么要创建readResolve方法,具体看源码)(如果类未实现Serializable接口,该方法可以忽略)
    */
    public Object readResolve() {
        return INSTANCE;
    }
}

4.饿汉式(枚举)(枚举本身是线程安全的)

java 复制代码
public enum Single {
    INSTANCE;
}

总结:

1.饿汉式是在类加载初始化时创建唯一实例,该实例在整个系统运行中会一直存在,不会被垃圾回收,直到系统停止;

2.隐性创建实例,使用方便,但存在内存浪费的问题(生命周期与系统的生命周期一致);

3.线程安全。

破坏单例模式的方式(以枚举创建的单例模式除外)

1.反序列化**(若单例模式未实现Serializable接口可忽略 ,只有实现了Serializable接口才会出现反序列化破坏单例模式的情况)**

java 复制代码
public class test {
    public static void main (String[] args) {
        writeObjectToFile();
        readObjectFromFile()
    }
    
    // 向文件中读数据
    public static void readObjectFromFile() throws Exception {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Lenovo\\Desktop\\a.txt"));
        Single s1 = (Single) ois.readObjecct();
        Single s2 = (Single) ois.readObjecct();
        System.out.println(s1 == s2);
        ois.close();
    }
    
    // 向文件中写数据
    public static void writeObjectToFile() throws Exception {
        Single single = Single.getInstance();
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Lenovo\\Desktop\\a.txt"));
        oos.writeObject(single);
        oos.close();
    }
}

通过反序列化的方式创建了多个不同的实例,破坏了单例模式。解决方案是新增readResolve()方法。新增的readResolve()方法已经存在上面的单例模式中。

2.反射

java 复制代码
public class test {
    public static void main (String[] args) {
        // 1.获取字节码对象
        Class clazz = Single.class;
        // 2.获取对象的无参构造器
        Constructor cons = clazz.getDeclaredConstructor();    
        // 3.因为无参构造器是私有的,所以取消权限访问的检查
        cons.setAccessible(true);
        // 4.创建对象
        Single s1 = (Single) cons.newInstance();
        Single s2 = (Single) cons.newInstance();
        System.out.println(s1 == s2);// false
    }
}

Java的反射机制可创建多个实例从而破坏单例模式,解决方案即是使用双重非空判断,加synchronized关键字是应对多线程的情况,所以synchronized+双重非空判断可防止反射破坏单例模式。代码的写法已经在上面的例子中写出来了。

扩展:

JDK中 - Runtime类使用的是单例模式(饿汉式)

java 复制代码
public class test{
    public static void main(String[] args){
        Runtime runtime = Runtime.getRuntime();
        // 参数是一个命令
        Process process = runtime.exec("ipconfig");
        InputStream is = process.getInputStream();
        byte[] arr = new byte[1024 * 1024 * 100];
        // 读取到数据的字节长度
        int len = is.read(arr);
        // 输入到控制台
        System.out.println(new String(arr, 0, len, "GBK"));
    }
}
相关推荐
鼠鼠我捏,要死了捏2 分钟前
深入实践G1垃圾收集器调优:Java应用性能优化实战指南
java·g1·gc调优
书院门前细致的苹果13 分钟前
ArrayList、LinkedList、Vector 的区别与底层实现
java
再睡亿分钟!16 分钟前
Spring MVC 的常用注解
java·开发语言·spring boot·spring
至此流年莫相忘29 分钟前
设计模式:策略模式
设计模式·策略模式
qq_1955516942 分钟前
代码随想录70期day7
java·开发语言
Sam-August1 小时前
【分布式架构实战】Spring Cloud 与 Dubbo 深度对比:从架构到实战,谁才是微服务的王者?
java·spring cloud·dubbo
麦兜*1 小时前
MongoDB 常见错误解决方案:从连接失败到主从同步问题
java·数据库·spring boot·redis·mongodb·容器
ytadpole2 小时前
揭秘设计模式:命令模式-告别混乱,打造优雅可扩展的代码
java·设计模式
用户3721574261352 小时前
Java 教程:轻松实现 Excel 与 CSV 互转 (含批量转换)
java
叫我阿柒啊2 小时前
Java全栈开发实战:从基础到微服务的深度解析
java·微服务·kafka·vue3·springboot·jwt·前端开发