单例模式

双重检测锁的懒汉式单例，称为DCL懒汉式。

//懒汉式单例
public class LazyMan {
    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }

    private static LazyMan lazyMan;

    
    public static LazyMan getInstance(){
        if (lazyMan==null){
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan = new LazyMan(); // 不是原子性操作
                    /*
                    * 1. 分配内存空间
                    * 2. 执行构造方法，初始化对象
                    * 3. 把这个对象执行这个空间
                     */
                }
            }
        }
        return lazyMan;
    }

    //多线程并发
/*    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                LazyMan.getInstance();
            }).start();
        }
    }*/
}

DCL懒汉式，在并发的环境下，它就是安全的了么？

并不是。因为lazyMan = new LazyMan(); ，不是原子性操作，可能出现指令重排。
正常创建对象 1. 分配内存空间2. 执行构造方法，初始化对象3. 将这个对象指向内存空间
可能会出现132的情况，先分配内存空间，之后将这个对象指向内存空间，最后才执行构造方法。
在出现指令重排的情况下，如果线程a，执行到3，还未执行2，这个时候线程b去获取实例，判断不为空，直接返回，这个时候线程b，拿到了错误的对象，也不符合单例模式的规范。