[设计模式]你写的单例模式，真的足够安全吗?

什么是单例模式

单例模式(Singleton Pattern)是Java中常用的设计模式之一，它的思想是只向外部提供一个获取实例的方法，对new关闭，从而保证整个系统中只存在一个仅实例化一次的类。

image.png

简单地实现单例模式-饿汉模式

Java通过new关键字来构造出对象实例，如果开发者不声明构造方法，默认缺省一个空参的构造函数。所以一般通过private关键字即可让调用者无法通过new关键字去创建对象实例，同时，向外提供getInstance()的静态方法，指向类中的private修饰的静态成员final域。

public class HungrySingletonDemo {
    // 静态域的成员变量
    private static final HungrySingletonDemo hungrySingleton = new HungrySingletonDemo();
    
    // 私有化的构造方法
    private HungrySingletonDemo() {
    }
    
    // 静态方法，提供访问实例的入口
    public static HungrySingletonDemo getInstance() {
        return hungrySingleton;
    }

    public static void main(String[] args) {
        System.out.println(getInstance());
        System.out.println(getInstance());
    }
}

思考一下，饿汉式的单例模式带来了什么隐患?

由于引用了static，导致类提前进行了实例化，造成资源浪费，而且会导致项目启动速度变慢。

无法抵御反射攻击与序列化攻击。

如果你坚持使用饿汉式单例模式，可以在私有化的构造函数中判断类是否已存在了一个实例，如果是，那么你可以抛出一个异常终止其他人通过反射去再次实例化你的单例类。

懒汉单例模式-使用双重检查锁来保证你的对象是线程安全的

双重检查锁的原理:

image.png

public class LazySingletonDemo {
    /**
     * 使用volatile让变量线程可见，防止指令重排序
     */
    private volatile static LazySingletonDemo instance = null;

    /**
     * 反射是可以破坏private的，所以这种单例模式并不是绝对的安全
     */
    private LazySingletonDemo() {
        System.out.println("The constructor is not absolute safe.");
    }

    public static LazySingletonDemo getInstance() {
        // 第一次检测
        if (instance == null) {
            // 同步锁，类锁
            synchronized (LazySingletonDemo.class) {
                // 如果另一个线程已经创建了这个类了，那么就不需要创建了
                if (instance == null) {
                    // memory = allocate() 1. 分配对象内存空间
                    // instance(memory) 2. 初始化对象
                    // instance = memory  3. 设置instance指向刚分配的内存地址，此时instance != null
                    // 2与3并无依赖关系，会导致指令重排序，所以需要加上volatile修饰符,否则会导致下一个线程进来直接返回一个并没有初始化的内存地址
                    instance = new LazySingletonDemo();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        System.out.println(getInstance());
        System.out.println(getInstance());
    }
}

synchronized可能会升级成重量级锁

仍然无法抵御反射与序列号攻击

枚举-简单并且强大的单例

Java的枚举思想: 通过公有的静态final域为每个枚举常量导出实例的类，因此没有可以访问的构造器，枚举类型是真正的final。因此无法通过new来创建枚举实例，也不能对它进行扩展，由JVM来保证类型安全。

@SuppressWarnings("all")
public class HungrySingletonEnumDemo {
    private HungrySingletonEnumDemo() {
    }

    public static HungrySingletonEnumDemo getInstance() {
        return ContainHolder.HOLDER.instance;
    }

    private enum ContainHolder {
        HOLDER;
        private HungrySingletonEnumDemo instance;

        ContainHolder() {
            instance = new HungrySingletonEnumDemo();
        }
    }


    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        // 通过单例获取的对象
        System.out.println(HungrySingletonEnumDemo.getInstance());
        Class clazz = HungrySingletonEnumDemo.class;
        Constructor constructor = clazz.getDeclaredConstructor();
        constructor.setAccessible(true);
        // 使用反射破坏private获取的对象
        HungrySingletonEnumDemo hungrySingletonEnumDemo = (HungrySingletonEnumDemo) constructor.newInstance();
        System.out.println(hungrySingletonEnumDemo.getInstance());
        Class containHolderClass = ContainHolder.class;
        // 报错,尝试使用枚举的构造函数进行反射侵入
        // Constructor containHolderConstructor = containHolderClass.getDeclaredConstructor();
        /**
         *     protected Enum(String name, int ordinal) {
         *         this.name = name;
         *         this.ordinal = ordinal;
         *     }
         */
        // Cannot reflectively create enum objects
        // 原因是枚举是使用static进行加载的，其实现也是一种饿汉的单例模式
        Constructor containHolderConstructor = containHolderClass.getDeclaredConstructor(String.class,int.class);
        containHolderConstructor.setAccessible(true);
        System.out.println(containHolderConstructor.newInstance());
    }
}

为什么无法通过反射创建枚举?

摘自: java.lang.reflect.Constructor#newInstance

    @CallerSensitive
    public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        // 无法反射创建枚举对象
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;   // read volatile
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        @SuppressWarnings("unchecked")
        T inst = (T) ca.newInstance(initargs);
        return inst;
    }