单例模式

Posted 2021-02-19 weixk

一、单例模式介绍

1、定义与类型

定义：保证一个类仅有一个实例，并提供一个全局访问点
类型：创建型

2、适用场景

想确保任何情况下都绝对只有一个实例

3、优点

在内存里只有一个实例，减少了内存开销
可以避免对资源的多重占用
设置全局访问点，严格控制访问

4、缺点

没有接口，扩展困难

5、重点

私有构造器：禁止从单例类外部构造对象
线程安全
延迟加载：使用时才创建
序列化和反序列化安全：序列化和反序列化会对单例模式进行破坏
反射：防御反射攻击

二、代码示例

1、懒汉式及多线程

注重延迟加载：

public class LazySingleton {
    private static LazySingleton lazySingleton = null;
    private LazySingleton(){
    }
    public static LazySingleton getInstance(){
        if(lazySingleton == null){
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

但是存在线程安全问题，所以可以增加synchronized：

public class LazySingleton {
    private static LazySingleton lazySingleton = null;
    private LazySingleton(){
    }
    public synchronized static LazySingleton getInstance(){
        if(lazySingleton == null){
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

2、Double Check双重检查

但是 synchronized 对性能存在影响，所以可以使用Double Check双重检查：

public class LazyDoubleCheckSingleton {
    private static LazyDoubleCheckSingleton lazyDoubleCheckSingleton = null;
    private LazyDoubleCheckSingleton(){
    }
    public static LazyDoubleCheckSingleton getInstance(){
        if(lazyDoubleCheckSingleton == null){
            synchronized (LazyDoubleCheckSingleton.class){
                if(lazyDoubleCheckSingleton == null){
                    lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton();
                }
            }
        }
        return lazyDoubleCheckSingleton;
    }
}

其中

lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton();

这一句代码包含三个步骤：
1.分配内存给这个对象
2.初始化对象
3.设置lazyDoubleCheckSingleton 指向刚分配的内存地址
在java语言规范中 允许在单线程内，不会改变单线程执行结果的重排序。
所以 2和3步可能会存在指令重排序，在单线程中，不会影响执行结果：

此时在多线程中：

此时线程1访问对象，但是对象在线程0中还没有初始化完成，可能就会报异常。
解决方案：
方案1、不允许2、3步骤重排序：
使用volatile关键字：

public class LazyDoubleCheckSingleton {
    private volatile static LazyDoubleCheckSingleton lazyDoubleCheckSingleton = null;
    private LazyDoubleCheckSingleton(){
    }
    public static LazyDoubleCheckSingleton getInstance(){
        if(lazyDoubleCheckSingleton == null){
            synchronized (LazyDoubleCheckSingleton.class){
                if(lazyDoubleCheckSingleton == null){
                    lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton();
                }
            }
        }
        return lazyDoubleCheckSingleton;
    }
}

使用了volatile后，所有线程都可以看到共享内存的最新状态，保证了内存的可见性。用volatile关键字修饰的变量，在进行写操作时，会多出一些汇编代码，将当前处理器缓存行的数据写回到内存，其中涉及到缓存一致性协议。

方案2、允许重排序，但不允许其他线程看到这个重排序，即静态内部类

3、静态内部类

基于类初始化的延迟加载解决方案

public class StaticInnerClassSingleton {
    private static class InnerClass{
        private static StaticInnerClassSingleton staticInnerClassSingleton = new StaticInnerClassSingleton();
    }
    public static StaticInnerClassSingleton getInstance(){
        return InnerClass.staticInnerClassSingleton;
    }
    private StaticInnerClassSingleton(){
    }
}

原理：存在Class对象的初始化锁，并且非构造线程，是看不到指令重排序的。
线程0初始化Class，线程1看不到初始化过程。所以静态内部类这种方法的核心在于InnerClass这个类的对象初始化锁

补充：类在以下几种情况下被初始化，1.实例被创建（new、反射、序列化），2.静态方法被调用，3.静态成员被赋值，4.非常量静态成员被使用，5.顶级类中有嵌套的断言语句，6.子类被初始化

4、饿汉式

最简单的写法：

public class HungrySingleton {
    private final static HungrySingleton hungrySingleton;
    static{
        hungrySingleton = new HungrySingleton();
    }
    private HungrySingleton(){
    }
    public static HungrySingleton getInstance(){
        return hungrySingleton;
    }
}

优点是类加载的时候就完成了初始化，避免了线程同步的问题
缺点是没有延迟加载的效果，可能造成累成内存浪费
饿汉与懒汉之间最大的区别就是延迟加载：饿汉式很饿，一上来就想吃东西，马上就把对象创建好了；而懒汉式非常懒，不用它的时候都不会创建这个对象。

5、序列化破坏单例模式

以下序列化和反序列化 将会破坏单例模式：

// 实现序列化接口
public class HungrySingleton implements Serializable {
    private final static HungrySingleton hungrySingleton;
    static{
        hungrySingleton = new HungrySingleton();
    }
    private HungrySingleton(){
    }
    public static HungrySingleton getInstance(){
        return hungrySingleton;
    }
}

测试类：

public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        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();
        System.out.println(instance);
        System.out.println(newInstance);
    }
}

反序列化是通过反射生成对象，反射时会判断是否存在并调用readResolve方法

所以可通过增加readResolve方法防止反序列化：

public class HungrySingleton implements Serializable{
    private final static HungrySingleton hungrySingleton;
    static{
        hungrySingleton = new HungrySingleton();
    }
    private HungrySingleton(){
    }
    public static HungrySingleton getInstance(){
        return hungrySingleton;
    }
    private Object reaResolve(){
        return hungrySingleton;
    }
}

但是在这个过程中，仍然被创建了新的对象，只是最后没有返回而已。

6、反射攻击

public class Test {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        Class<HungrySingleton> hungrySingletonClass = HungrySingleton.class;
        Constructor<HungrySingleton> declaredConstructor = hungrySingletonClass.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        HungrySingleton instance = HungrySingleton.getInstance();
        HungrySingleton newInstance = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(newInstance);
        System.out.println(instance == newInstance);
    }
}

对于饿汉式单例、静态内部类单例，因为是在类初始化时就创建了对象，所以可在构造器中进行反射防御：

public class HungrySingleton implements Serializable{
    private final static HungrySingleton hungrySingleton;
    static{
        hungrySingleton = new HungrySingleton();
    }
    private HungrySingleton(){
        // 反射防御、第二次调用就会报错	
        if(hungrySingleton != null){
            throw new RuntimeException("单例构造器禁止反射调用");
        }
    }
    public static HungrySingleton getInstance(){
        return hungrySingleton;
    }
    private Object readResolve(){
        return hungrySingleton;
    }
}

而对于不是在类初始化时创建对象的单例模式，则无法防御反射攻击，例如懒汉式单例模式：

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

因为在被反射攻击的时候，单例可能还没有被创建，所以会产生不同实例，测试类：

public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        // 反射攻击
        Class<LazySingleton> lazySingletonClass = LazySingleton.class;
        Constructor<LazySingleton> declaredConstructor = lazySingletonClass.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        // 先反射
        LazySingleton newInstance = declaredConstructor.newInstance();
        // 后取单例，构造器的判断没有起到想要的作用
        LazySingleton instance = LazySingleton.getInstance();

        System.out.println(instance);
        System.out.println(newInstance);
        System.out.println(instance == newInstance);
    }
}

可以增加信号量进行控制：

public class LazySingleton {
    private static LazySingleton lazySingleton = null;
    private static boolean flag = true;
    private LazySingleton(){
        if (flag){
            flag = false;
        } else {
            throw new RuntimeException("单例构造器禁止反射调用");
        }
    }
    public synchronized static LazySingleton getInstance(){
        if(lazySingleton == null){
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

但是信号量仍然可以被修改，以达到反射破坏：

public class Test {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, NoSuchFieldException, InvocationTargetException {
        Class objectClass = LazySingleton.class;
        Constructor c = objectClass.getDeclaredConstructor();
        c.setAccessible(true);

        LazySingleton o1 = LazySingleton.getInstance();

        Field flag = o1.getClass().getDeclaredField("flag");
        flag.setAccessible(true);
        flag.set(o1,true);

        LazySingleton o2 = (LazySingleton) c.newInstance();

        System.out.println(o1);
        System.out.println(o2);
        System.out.println(o1==o2);
    }
}

7、Enum枚举单例

枚举类型天然的可序列化机制，能够强有力得保证不会多次实例化的情况。即使在复杂的序列化或者反射攻击下，枚举模式都没有问题。

public enum EnumInstance {
    INSTANCE{
        protected  void printTest(){
            System.out.println("Geely Print Test");
        }
    };
    protected abstract void printTest();
    private Object data;
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }
    public static EnumInstance getInstance(){
        return INSTANCE;
    }
}

在ObjectInputStream中，对于枚举类型，是通过枚举类直接获得唯一的枚举常量，没有创建新的对象，维护了枚举的单例属性：

而对于反射，在调用
objectClass.getDeclaredConstructor();
时会直接报错：
java.lang.NoSuchMethodException
原因在于Enum本身就只有一个构造器：

而如果调用

Constructor constructor = objectClass.getDeclaredConstructor(String.class,int.class);
constructor.setAccessible(true);
EnumInstance instance = (EnumInstance) constructor.newInstance("11",22);

也会直接报错：java.lang.IllegalArgumentException: Cannot reflectively create enum objects

如果通过jad反编译枚举类，可以看到：1.class类为final的；2.构造器为private；3.声明的枚举对象是static和final的；4.枚举对象在static代码块中实例化
所以枚举单例是最安全的单例模式

8、容器单例

public class ContainerSingleton {

    private ContainerSingleton(){
    }
    private static Map<String,Object> singletonMap = new HashMap<String,Object>();

    public static void putInstance(String key,Object instance){
        if(StringUtils.isNotBlank(key) && instance != null){
            if(!singletonMap.containsKey(key)){
                singletonMap.put(key,instance);
            }
        }
    }
    public static Object getInstance(String key){
        return singletonMap.get(key);
    }
}

容器单例与享元模式相似
优点：统一管理，节省资源，相当于缓存
缺点：存在线程安全问题

9、ThreadLocal线程单例

public class ThreadLocalInstance {
    private static final ThreadLocal<ThreadLocalInstance> threadLocalInstanceThreadLocal
             = new ThreadLocal<ThreadLocalInstance>(){
        @Override
        protected ThreadLocalInstance initialValue() {
            return new ThreadLocalInstance();
        }
    };
    private ThreadLocalInstance(){

    }
    public static ThreadLocalInstance getInstance(){
        return threadLocalInstanceThreadLocal.get();
    }
}

这个单例 并不能保证整个应用全局唯一，但能保存线程唯一。
ThreadLocal会为每一个线程提供一个变量副本，本身是基于ThreaLocalMap实现的，维持了线程间的隔离。原理是以空间换时间的方式，会创建很多对象，在一个线程里会创建唯一的一个对象。在多线程访问的时候，彼此不会相互影响。

三、源码示例

1、JDK中的Runtime：饿汉式

2、JDK中的Desktop：懒汉式+容器式+线程安全控制

3、spring

4、mybatis：ThreadLocal