关于java:单例模式详解

思维导图

概念

保障一个零碎中的一个类，只有一个实例

实现

私有参数

/** * 私有参数实现 */public class Singleton {    public static final Singleton INSTANCE = new Singleton();    private Singleton() {    }}

长处：简略
毛病：违反了java的封装

饿汉式

/** * 饿汉式 */public class Singleton {    private static final Singleton INSTANCE = new Singleton();    private Singleton() {    }    public static Singleton getInstance(){        return INSTANCE;    }}

长处：应用前就创立好实例，多线程平安
毛病：加载Singleton.class文件的时候，实例对象就创立了，节约了内存

懒汉式

/** * 懒汉式 */public class Singleton {    private static Singleton instance;    private Singleton() {    }    public static Singleton getInstance(){        if(instance == null){            instance = new Singleton();        }        return instance;    }}

毛病：多线程并发下不平安，可能会创立多个实例
长处：只有调用getInstance()办法才会创立实例

Double CheckLock

/** * Double CheckLock */public class Singleton {    private static Singleton instance;    private Singleton() {    }    public static Singleton getInstance(){        if(instance == null){            //为什么要先判断在加锁 因为instance只有刚开始的时候为null，            //前面都不会为null，防止后续应用中的不必要的同步            synchronized (Singleton.class){                if(instance == null){                    instance = new Singleton();                }            }        }        return instance;    }}

长处：线程平安，效率高
毛病：实现简单

动态外部类

/** * 动态外部类 */public class Singleton {    private Singleton() {    }    public static Singleton getInstance(){        return SingletonHold.instance;    }    public static class SingletonHold{        private static Singleton instance = new Singleton();    }}

长处：线程平安，只有在调用getInstance办法时，才会创立实例

枚举

/** * 枚举单例 */public enum Singleton {    INSTANCE;}

长处：实现超级简略

序列化问题

测试代码

public class Singleton implements Serializable {    private Singleton() {    }    public static Singleton getInstance() {        return SingletonHold.instance;    }    static class SingletonHold {        private static Singleton instance = new Singleton();    }    public static void main(String[] args) throws Exception {        try (                FileOutputStream fileOutputStream = new FileOutputStream("d://text.txt");                FileInputStream fileInputStream = new FileInputStream("d://text.txt");                ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);                ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream)        ) {            Singleton s1 = Singleton.getInstance();            objectOutputStream.writeObject(s1);            Singleton s2 = (Singleton) objectInputStream.readObject();            System.out.println(s1 == s2);        } catch (Exception e) {            System.out.println("序列化异样");        }    }}

测试后果

剖析

序列化后的单例再把他序列化回来，是两个不同的对象

防止序列化问题

 private Object readResolve() throws ObjectStreamException {        return SingletonHold.instance;    }

在之前的代码中退出这一个办法即可

为什么加了这一段代码就能够呢

343行：ObjectStreamClass的lookup办法

391行：lookup办法中的这一行结构了entry对象，进入构造方法

520行：反射查找要序列化的对象是否有writeObject办法
523行：反射查找要序列化的对象是否有readObject办法
526行：反射查找要序列化的对象是否有readObjectNoData办法
531行：反射查找要序列化的对象是否有writeReplace办法
533行：反射查找要序列化的对象是否有readResolve办法

2078行：反序列化的时候，如果有readResolve办法，就调用readResolve办法返回序列化对象
所以加了这一段代码之后，方序列化就会返回SingletonHold.instance，所以是同一个对象