单例模式

单例模式。

单例模式确保一个类只有一个实例，并提供全局的访问点，通过一个私有构造函数、私有静态变量和一个公有静态函数实现。

单例模式分为懒汉式和饿汉式实现。

**懒汉式：线程不安全。**延迟加载，若多个线程同时进入到if(uniqueInstance==null),则会导致多次实例化。

饿汉式：线程安全。直接实例化，则不会多次实例化。

如何使懒汉式线程安全？

方法一：对 getInstance加锁：性能太差

方法二：双重校验。先判断是否实例化，若没有实例化则加锁后再判断是否实例化进行实例化，注意对类变量加volatile关键字防止指令重排；

public class Singleton {
    private volatile Singleton instance = null;
    private Singleton() {
    }
    public static Singleton getUniqueInstance() {
        if(instance == null){
            synchronized(Singleton.class){
                 if(instance == null){
                     this.instance = new Singleton();
                 }
            }
        }
        return instance;
    }
}

方法三：静态内部类实现。当 Singleton 类被加载时，静态内部类 SingletonHolder 没有被加载进内存。这种方式不仅具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。

public class Singleton {
    private Singleton() {
    }
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }         

    public static Singleton getUniqueInstance() {
        return SingletonHolder.INSTANCE;
    }
}

反射攻击？

可以通过反射将构造函数设置为公有，然后调用构造函数实例化；

可以通过枚举方式实现单例模式，防止反射攻击。

方法四：枚举实现。

public class Singleton {
    private Singleton(){}

    //定义一个内部的枚举类实现单例
    private enum SingletonEnum{
        INSTANCE;
        private final Singleton instance;

        private SingletonEnum() {  //枚举的构造方法默认是private
            instance = new Singleton();
        }
        private Singleton getInstance(){
            return instance;
        }
    }

    private static Singleton getInstance(){
        return SingletonEnum.INSTANCE.getInstance();
    }

    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance == instance1);

    }
}