缓存导致的可见性问题

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

如果是单核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;}
}