造成并发安全的三大源头：可见性、原子性、有序性

缓存导致的可见性问题

一个线程对共享变量的修改，另外一个线程能够立刻看到，我们称为 可见性

如果是单核cpu，cpu之间的线程共享一个缓存，这个时候不会出现缓存与内存数据一致性的问题，同样的线程之间具备可见性

如果是多核cpu，cpu之间的线程共享各自的缓存，这个时候就会出现缓存与内存数据一致性的问题，同时线程之间不具备可见性

public class Demo1 {
    static int count = 0;
    public void add10k(){
        int idx = 0;
        while(idx++ < 10000){
            count++;
        }
    }

    public static void main(String[] args) {
        final Demo1 demo1 = new Demo1();
        Thread thread1 = new Thread(() -> {
            demo1.add10k();
        });
        Thread thread2 = new Thread(() -> {
            demo1.add10k();
        });
        thread1.start();
        thread2.start();
        //等待结果
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(count);
    }
}

操作之间的原子性问题

原子性指的是把一个操作或者多个操作在cpu执行的过程不被中断的特性

count += 1 cpu指令分为三步 1.读取到寄存器 2.执行加法操作 3.写入到内存中

如果线程1执行到1，此时cpu时间片用完，线程2执行，线程2执行完123步，回到线程1执行，此时就发生了线程安全问题

public class Demo2 {
    static int count = 0;
    public void add(){
        count += 1;
    }

    public static void main(String[] args) {
        final Demo2 demo2 = new Demo2();
        Thread thread1 = new Thread(() -> {
            count += 1;
        });
        Thread thread2 = new Thread(() -> {
            count += 1;
        });
        thread1.start();
        thread2.start();
        //等待结果
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(count);
    }
}

有序性问题

程序按照代码的顺序执行叫做有序性

但是编译器有可能会将代码语句的顺序进行调换，进行优化，此时就有可能会造成线程安全问题

双重校验锁就是最经典的例子

假设有线程1和线程2同时想要创建demo3这个对象，线程1和线程2同时进入到if (demo3 == null)这个判断中以后线程1先获取到锁将demo3创建出来释放锁对象

线程2获取到锁发现demo3不为null了所以放弃创建释放锁

但是由于指令重排序的存在，导致会出现线程安全问题

正常的逻辑是 1.为demo3开辟内存空间 2.在内存上初始化Demo3对象 3.将demo3指向内存空间

但是由于指令重排序可能会导致 1.为demo3开辟内存空间 3.将demo3指向内存空间 2.在内存上初始化Demo3对象

此时假设线程1和线程2同时想要创建demo3这个对象，线程1先进入到if (demo3 == null)这个判断中以后线程1执行1、3还没有执行2的时候，时间片刚好用完切换到线程2执行任务

线程2也进入到if (demo3 == null)这个判断中，此时线程2发现demo3不为null了直接返回demo3，但此时的demo3还没有初始化完成，所以线程2返回的demo3对象是不完整的，也就导致到线程安全问题

public class Demo3 {
    //双重校验锁 - 加上volatile禁止指令重排序
    private volatile static Demo3 demo3;
    static Demo3 getInstance(){
        if (demo3 == null){
            synchronized (Demo3.class){
                if (demo3 == null){
                    demo3 = new Demo3();
                }
            }
        }
        return demo3;
    }
}