单例模式-最优雅解法

1. 双层检查

public class SingletonDemo1 {

    private static SingletonDemo1 instance;


    private SingletonDemo1() {
    }

    /**
     * 双层null检查.
     * 优点: 在于最多只会加锁两次.
     * 缺点: 可能因为构造函数中JVM进行重排序, 导致使用instance的时候, 发生nullPointerException. 
     * new Object()分为三步:
     *   1. 申请内存空间.
     * 	 2. 把指针指向这个内存空间.
     *   3. 初始化这个对象.
     *   而2和3可能出现内存重排序的问题。因为jvm规范允许内存重排序，只要不影响到最后的结果.
     * 修补方法：private static volatile SingletonDemo1 instance; 使用了Volatile保证了数据
     * 不会重排, 且多线程见数据可见.
     */
    public static SingletonDemo1 getInstance() {
        if (null == instance) {
            synchronized (SingletonDemo1.class) {
                if (null == instance) {
                    instance = new SingletonDemo1();
                }
            }
        }

        return instance;
    }
}

2. 内部类Holder

public class SingletonDemo2 {

    private SingletonDemo2() {

    }

    /**
     * 使用静态内部类, 只有当使用到InstanceHolder的时候, 才会加载,
     * 且static修饰过的数据, JVM不会进行重排.
     * JVM会在类初始化的时候, 加上锁, 防止别的线程访问.
     */
    private static class InstanceHolder {
        private final static SingletonDemo2 instance = new SingletonDemo2();
    }

    public static SingletonDemo2 getInstance() {
        return InstanceHolder.instance;
    }
}

3. 使用enum作为单例

public class SingletonDemo3 {

    private SingletonDemo3() {

    }
    
    private enum Instance {
        INSTANCE;

        private final SingletonDemo3 instance;

        // enum构造函数只会创建一次.
        Instance() {
            instance = new SingletonDemo3();
        }

        public SingletonDemo3 getInstance() {
            return instance;
        }
    }

    public static SingletonDemo3 getInstance() {
        return Instance.INSTANCE.getInstance();
    }

    public static void main(String[] args) {
        IntStream.range(0, 100).forEach((item) -> {
            Thread thread = new Thread(() -> {
                System.out.println(SingletonDemo3.getInstance());
            });

            thread.start();
        });
    }

}