单例设计模式

单例模式

概念：

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

1.懒汉式

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.饿汉式（静态变量）

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.饿汉式（静态代码块）

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.饿汉式（枚举）（枚举本身是线程安全的）

public enum Single {
    INSTANCE;
}

总结：

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

        2.隐性创建实例，使用方便，但存在内存浪费的问题（生命周期与系统的生命周期一致）；

        3.线程安全。

破坏单例模式的方式（以枚举创建的单例模式除外）

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

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.反射

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类使用的是单例模式（饿汉式）

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