一、原子性
原子性指操作在CPU执行的过程中，不可中断，也不可在中途切换，要么执行完成要么不执行。
package learn;
/**
* @author qx
* @date 2024/1/5
* @des
*/
public class ThreadAtomicityTest {
private int step;
public int getStep() {
return step;
}
public void increaseStep() {
step++;
}
}线程执行的指令包含三大步骤:
1.将变量step从内存中加载到CPU的寄存器中；
2.在CPU的寄存器中执行step++操作；
3.将step++后的结果写入缓存（CPU缓存或计算机内存）；
线程切换可能发生在任何一条指令完成之后，而不是Java某条语句完成后。
假设线程1和线程2同时执行increaseStep()方法，在线程1执行过程中，CPU完成指令码的步骤①后发生了线程切换，此时线程2开始执行指令码的步骤①。当两个线程都执行完整个increaseStep()方法后，得到的step的值是1而不是2。
代码实例如下所示:
package learn;
/**
* @author qx
* @date 2024/1/5
* @des
*/
public class ThreadTest {
public static void main(String[] args) {
ThreadAtomicityTest threadAtomicityTest =new ThreadAtomicityTest();
new Thread(()->{
threadAtomicityTest.increaseStep();
}).start();
new Thread(()->{
threadAtomicityTest.increaseStep();
}).start();
System.out.println(threadAtomicityTest.getStep());
}
}输出结果:
1这个问题具体是怎么样产生的呢?
线程1将step=0加载到CPU的寄存器后，发生了线程切换。此时还没有执行step++操作，也没有将操作的结果写入内存，所以，内存中的step值仍为0。
线程2将step=0加载到CPU的寄存器中，执行step++操作，并将执行后的结果写入内存。此时，CPU切换到线程1继续执行，在执行线程1中的step++后，线程1中的step仍为1，线程1将step=1写入内存，最终内存中的step为1。
如果在CPU中存在正在执行的线程，此时，发生了线程切换，就可能导致并发编程的原子性问题。
所以，造成原子性问题的根本原因是在线程执行过程中发生了线程切换。
二、可见性
可见性指一个线程修改了共享变量，其他线程能够立刻读到共享变量的最新值。在并发编程中，有两种情况能实现当一个线程修改了共享变量后，其他线程立刻就能读到最新值。
1.串行
比如有2个线程，线程是串行执行的，线程1写完数据后，线程2才执行并从主内存中读取到数据，线程1向主内存中写入数据对线程2是可见的，所以线程1和线程2之间不存在可见性问题。
2.单核CPU
在单核CPU中，多个线程之间也不会出现可见性问题。在单核CPU中，只能有一个线程占用CPU资源来执行任务，其他线程获取CPU资源执行任务时，共享变量中的值一定是最新的。
3.多线程多CPU时可见性问题
Java中，多个线程在读写内存中的共享变量时，会先把主内存中的共享变量数据复制到线程的工作内存中。每个线程在对数据进行读写操作时，都是直接操作自身的工作内存中的数据。由于每个线程都有自己的工作内存，所以线程1的数据对线程2是不可见的。线程1修改了数据，线程2不一定能够立刻读到修改后的值，这就造成了可见性问题。
package learn;
/**
* @author qx
* @date 2024/1/5
* @des
*/
public class SynchronizedTest {
private static int count = 0;
public static void incrementCount() {
count++;
}
public static int increment() throws InterruptedException {
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
incrementCount();
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
incrementCount();
}
});
thread1.start();
thread2.start();
thread1.join();
thread2.join();
return count;
}
public static void main(String[] args) throws InterruptedException {
System.out.println("count=" + SynchronizedTest.increment());
}
}控制台输出:
count=1942三、有序性
有序性指程序能够按照编写的代码顺序执行，不会发生跳过代码行的情况，也不会出现跳过CPU指令的情况。
为了提高程序的执行性能和编译性能，计算机和编译器有时候会修改程序的执行顺序。
在Java中一个典型的案例就是使用双重检测机制来创建单例对象。
package learn;
/**
* @author qx
* @date 2024/1/5
* @des
*/
public class SingleInstance {
private SingleInstance() {
}
private static SingleInstance singleInstance;
public static SingleInstance getInstance() {
if (singleInstance == null) {
synchronized (SingleInstance.class) {
if (singleInstance == null) {
singleInstance = new SingleInstance();
}
}
}
return singleInstance;
}
}假如线程1和线程2同时调用getInstance()方法获取对象实例，两个线程会同时发现instance为空，同时对SingleInstance.class加锁，而JVM会保证只有一个线程获取到锁，这里我们假设线程1获取到锁，线程2因为未获取到锁而进行等待。接下来，线程1再次判断instance对象为空，从而创建instance对象的实例，然后释放锁。此时，线程2被唤醒，再次尝试获取锁，获取锁成功后，线程2检查此时的instance对象已经不再是空，线程2不再创建instance对象。
上述流程看起来没有什么问题，但是，在高并发、大流量的场景下获取instance对象时，使用new关键字创建SingleInstance类的实例对象时，会因为编译器或解释器对程序的优化而出现问题。
instance = new SingleInstance();对于上面的代码包含三个步骤：
① 分配内存空间
② 初始化对象
③ 将instance引用指向内存空间
正常执行的CPU指令顺序为①②③，CPU对程序进行重排序后的执行顺序是①③②，此时就会出现问题。
当线程1判断instance为空时，为对象分配内存空间，并将instance指向内存空间。此时还没有进行对象的初始化，发生了线程切换，线程2获取到CPU资源执行任务。线程2判断此时的instance不为空，则不再执行创建对象的操作，直接返回未初始化的instance对象。
所以，造成有序性问题的根本原因是编译器对程序进行优化，从而可能造成有序性问题。
四、解决方案
在Java中解决原子性问题的方案包括synchronized、Lock、ReentranLock、ReadWriteLock、CAS操作、Java中提供的原子类等。
解决可见性和有序性问题，可以禁用CPU缓存和编译器优化。
JVM提供了禁用缓存和编译优化的方法，包括volatile关键字、synchronized、final关键字以及Java内存模型中的Happens-Before原则。
