单例模式详解

思维导图

image.png

概念

保证一个系统中的一个类,只有一个实例

实现

公有参数

/**
 * 公有参数实现
 */
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("序列化异常");
        }
    }
}

测试结果

image.png

分析

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

避免序列化问题

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

在之前的代码中加入这一个方法即可

为什么加了这一段代码就可以呢

image.png
343行:ObjectStreamClass的lookup方法
image.png
391行:lookup方法中的这一行构造了entry对象,进入构造方法
image.png
520行:反射查找要序列化的对象是否有writeObject方法
523行:反射查找要序列化的对象是否有readObject方法
526行:反射查找要序列化的对象是否有readObjectNoData方法
531行:反射查找要序列化的对象是否有writeReplace方法
533行:反射查找要序列化的对象是否有readResolve方法
image.png
2078行:反序列化的时候,如果有readResolve方法,就调用readResolve方法返回序列化对象
所以加了这一段代码之后,方序列化就会返回SingletonHold.instance,所以是同一个对象

评论

暂无评论