设计模式之单例模式

设计模式之单例模式

维基百科定义

单例模式，也叫单子模式，是一种常用的软件设计模式，属于创建型模式的一种。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。

简单定义

保证一个类仅有一个实例，并提供一个全局访问点。

场景

比如：数据库连接池、系统全局的计数器、线程池

单例需要关注的点

1：私有构造器
2：线程安全
3：延迟加载
4：序列化和反序列化安全
5：反射

实现-懒汉式单例

public class LazySingleton {
    //唯一实例
    private static LazySingleton lazySingleton = null;
    
    //私有构造器
    private LazySingleton(){
        //懒汉式的这里无法解决反射，这取决于反射在第一次getInstance之前还是之后
        if(lazySingleton != null){
            throw new RuntimeException("单例构造器禁止反射调用");
        }
    }
    
    //全局访问点。注意这里一定要使用 synchronized 防止多线程环境下生成多个实例，缺点是锁的粒度有点大，牺牲了性能
    public synchronized static LazySingleton getInstance(){
        if(lazySingleton == null){
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

演进版本1：使用 Doublecheck 改善性能，让锁的粒度更小。

public class LazyDoubleCheckSingleton {
    //唯一实例。注意1：需要使用 volatile 修饰，目的是为了解决注意3中cpu指令重排序，导致的多线程环境下拿到不成熟对象
    private volatile static LazyDoubleCheckSingleton lazyDoubleCheckSingleton = null;
    
    private LazyDoubleCheckSingleton(){
        //解决反射攻击
        if(lazyDoubleCheckSingleton != null){
            throw new RuntimeException("单例构造器禁止反射调用");
        }
    }
    
    //全局访问点。
    public static LazyDoubleCheckSingleton getInstance(){
        if(lazyDoubleCheckSingleton == null){
            synchronized (LazyDoubleCheckSingleton.class){
                //注意2：Double check。多线程环境下可能多个线程按顺序进入这里
                if(lazyDoubleCheckSingleton == null){
                    //注意3：这里在操作系统中是多个指令。
                    //1）分配内存；2）初始化对象；3）指向内存地址。2 和 3 可能重排序，导致其他线程拿到未初始化的对象
                    lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton();
                   
                }
            }
        }
        return lazyDoubleCheckSingleton;
    }
}

演进版本2：演进版本1使用volatile禁止CPU指令重排序，演进版本2使用内部静态类来屏蔽线程指令重排序。

public class StaticInnerClassSingleton {
    private static class InnerClass{
        private static StaticInnerClassSingleton staticInnerClassSingleton = new StaticInnerClassSingleton();
    }
    public static StaticInnerClassSingleton getInstance(){
        return InnerClass.staticInnerClassSingleton;
    }
    private StaticInnerClassSingleton(){
        if(InnerClass.staticInnerClassSingleton != null){
            throw new RuntimeException(" ");
        }
    }
}

实现-饿汉式单例

    public class HungrySingleton implements Serializable,Cloneable{
    
    //用final修饰，在类加载的时候就初始化了，后面也无法更改了
    private final static HungrySingleton hungrySingleton;

    static{
        hungrySingleton = new HungrySingleton();
    }
    private HungrySingleton(){
        if(hungrySingleton != null){
            throw new RuntimeException("单例构造器禁止反射调用");
        }
    }
    public static HungrySingleton getInstance(){
        return hungrySingleton;
    }
}

序列化破坏单例模式

破坏步骤：
1）获取单例对象，将对象写入文件；
2）从文件中读取，将读取结果转换成对象；
结果：转换的对象 和 单例对象 不是同一个对象，单例被破坏；

        HungrySingleton instance = HungrySingleton.getInstance();
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton_file"));
        oos.writeObject(instance);

        File file = new File("singleton_file");
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));

        HungrySingleton newInstance = (HungrySingleton) ois.readObject();

解决方法：
原理：ObjectInputStream 类的 readObject0 方法在转换成Obeject的时候会检验：checkResolve，如果有的话实现了会直接调用。
所以在单例类中增加下面方法即可：

private Object readResolve(){
        return hungrySingleton;
}

反射破坏单例模式

反射主要是通过构造器生成一个新的对象。对于饿汉式单例，单例在类加载的时候就已经创建好了，所以在构造器中加上单例判空的逻辑即可；对于懒汉式单例，是无法解决反射问题的，取决于反射调用在生成对象之前还是之后。

枚举单例

枚举是天然防反射和防反序列化的。ObjectInpuctStream 类 和 Constructor 都对枚举类做了特殊的处理。枚举为单例的最佳实现方式。

public class Singleton {
    private Singleton(){
    }   
    public static enum SingletonEnum {
        SINGLETON;
        private Singleton instance = null;
        private SingletonEnum(){
            instance = new Singleton();
        }
        public Singleton getInstance(){
            return instance;
        }
    }
}