单例模式的理解记录

/**
 * DCL单例模式：懒汉式加并发控制，保证多线程情况下，有且仅有一个对象
 * 1、构造器私有化：避免外部创建对象
 * 2、私有的静态属性：用来存储对象地址
 * 3、公共的静态方法：为外界返回对象引用
 *
 * @Authror wey
 * @Date 2020/5/13 12:10
 */
public class DoubleCheckingLocking {
    /**
     * 私有属性
     * 使用volatile修饰，是保证数据同步
     * 在new DoubleCheckingLocking 的时候经历三个步骤
     * 1、开辟空间
     * 2、初始化对象
     * 3、返回对象的地址给引用
     * 因为第三步和第二步并没有什么关联，会出现指令重排，
     * 这样当出现多线程的时候，还在初始化对象的时候，就有可能将对象的地址给返回了
     * 所以会出现null
     * volatile就解决了指令重排的问题，只要有改动就执行不会重排
     */
    private static volatile DoubleCheckingLocking instance;

    /**
     * 私有无参构造器
     */
    private DoubleCheckingLocking() {

    }

    /**
     * 提供对外的静态方法获取对象实例
     *
     * @return
     */
    public static DoubleCheckingLocking getInstanceDelay(long delayTime,boolean doubleCheck,boolean sync) {
        if(doubleCheck){
            if(null != instance){
                return instance;
            }
        }
        if(sync) {
            synchronized (DoubleCheckingLocking.class) {
                instance(delayTime);
            }
        }
        instance(delayTime);
        return instance;
    }

    private static void instance(long delayTime) {
        if (null == instance) {
            //模拟创建对象延迟的情况
            try {
                Thread.sleep(delayTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new DoubleCheckingLocking();
        }
    }

    public static void main(String[] args) {
        test();
    }

    /**
     * 分别测试：无延时，有延时
     *         无双重检测，有双重检测
     *         无同步，有同步
     */
    private static void test(){
        new Thread(() -> {
            DoubleCheckingLocking dcl1 = DoubleCheckingLocking.getInstanceDelay(500,false,true);
            System.out.println(dcl1);
        }).start();

        DoubleCheckingLocking dcl2 = DoubleCheckingLocking.getInstanceDelay(1000,false,true);
        System.out.println(dcl2);
    }
}

以上是各种情况的测试，以下是完整单例的案例：

public class Example {

    private static volatile Example instance;

    private Example(){}

    public static Example getInstance(){
        if(null != instance){
            return instance;
        }
        synchronized (Example.class){
            if(null == instance){
                instance = new Example();
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println(Example.getInstance());
        }).start();
        System.out.println(Example.getInstance());
    }
}

单例模式的理解记录

原文：https://www.cnblogs.com/w2cl/p/12882143.html