singleton中衍生的问题

Spring中的单例

Spring框架里的bean，或者说组件，获取实例的时候都是默认的单例模式，这是在多线程开发的时候要尤其注意的地方。
单例模式的意思就是只有一个实例。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。

下面是几种常见的单例实现方式

/**
 * @description:饿汉法：在第一次引用该类的时候就创建对象实例，而不管实际是否需要创建
 * @author: hdh
 * @date: 2022/4/13 16:25
 */
public class Singleton1 {

    private static Singleton1 singleton1 = new Singleton1();

    private Singleton1() {
    }

    public static Singleton1 getSingleton1() {

        return singleton1;

    }
}

/**
 * @description:懒汉法单线程：在需要使用的时候计加载实现延时加载
 * @author: hdh
 * @date: 2022/4/13 16:25
 */
public class Singleton2 {

    private static Singleton2 singleton2 = null;

    private Singleton2() {
    }

    public static Singleton2 getSingleton2() {

        if (Objects.isNull(singleton2)) {

            singleton2 = new Singleton2();
        }

        return singleton2;
    }

}

/**
 * @description:懒汉法多线程：在需要使用的时候计加载实现延时加载
 * @author: hdh
 * @date: 2022/4/13 16:25
 */
public class Singleton3 {

    private static volatile Singleton3 singleton3 = null;

    private Singleton3() {
    }

    public static Singleton3 getSingleton3() {
        if (singleton3 == null) {
            synchronized (Singleton3.class) {
                if (singleton3 == null) {
                    singleton3 = new Singleton3();
                }
            }
        }
        return singleton3;
    }

}

衍生问题

volatile 1.5之后的可见性和禁止指令重排
可见性:指在多线程中当一个线程修改了某个共享变量的值，其他线程是否能够马上得知这个修改的值。
禁止指令重排:

    int a= 0;
    boolean flag = false;

    public void method01() {
        a = 1;
        flag = true;
    }

    public void method02() {
        if(flag) {
            a = a + 5;
            System.out.println("reValue:" + a);
        }
    }
}

我们按照正常的顺序，分别调用method01() 和 method02() 那么，最终输出就是 a = 6
但是如果在多线程环境下，因为方法1 和 方法2，他们之间不能存在数据依赖的问题，因此原先的顺序可能是

a = 1;
flag = true;

a = a + 5;
System.out.println("reValue:" + a);

但是在经过编译器，指令，或者内存的重排后，可能会出现这样的情况

flag = true;

a = a + 5;
System.out.println("reValue:" + a);

a = 1;

也就是先执行 flag = true后，另外一个线程马上调用方法2，满足 flag的判断，最终让a + 5，结果为5，这样同样出现了数据不一致的问题

为什么会出现这个结果：多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。
内存屏障（Memory Barrier）又称内存栅栏，是一个CPU指令，它的作用有两个：
保证特定操作的顺序
保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）
也就是过在Volatile的写 和 读的时候，加入屏障，防止出现指令重排的
内存可见性
线程A初始化number=0，执行后进入while循环。当main线程执行后在main线程中修改number=60但此时number的值未修改到内存中，A线程任然在while中循环
Volatile：在多线程下当A线程修改了某个变量，在b线程中可以马上体现

class MyDate {
    //共享变量 1.1 首先不加volatile关键字
   volatile int number = 0;

    public void change() {
        this.number = 60;
    }
}

/**
 * 1.验证volatile的可见性
 */
public class VolatileDemo {
    public static void main(String[] args) {
        MyDate myDate = new MyDate();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t come in");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myDate.change();
            System.out.println(Thread.currentThread().getName() + "\t update number value=" + myDate.number);
        }, "A线程").start();

        //main线程读到的数据
        while (myDate.number == 0) {
            //main 线程一直循环等待直到number值不等于0
        }
        System.out.println(Thread.currentThread().getName() + "\t over number value="+myDate.number);
    }
}