volatile 的那点小事儿

先简单回忆下基础知识，Java 中内存模型的三大特性：原子、有序、可见：

1. 原子性：即一个操作要么成功，要么失败，没有第三种状态
2. 有序性：编译器和处理器在执行代码的时候，会将没有强依赖的多个指令进行重新排序，来提高执行效率，比如耗时长的放前面，趁机做些别的小操作等等
3. 可见性：线程从内存中访问变量，是先将变量从主内存拷贝到线程的工作内存中（高速缓存或者寄存器），再进行操作。那么在多线程场景下，就有可能出现线程A刚拷贝了个变量，线程B就将主内存的变量更新了，而此时线程A的变量就不是最新的了，这就是不可见

volatile 关键字保证了并发环境下的有序（内存屏障禁止重排）和可见（MESI 协议缓存行失效），但并没有保证原子性。

所以在进行并发计算的时候，不能只使用 volatile，要结合 synchronized 或者使用原子类。

下面看两个栗子：

/**
 * @Author Joy
 * @Date 2021/8/28
 * @Desc volatile 无法保证并发计算安全，解决方法：increse 加上 synchronized 修饰
 */
public class VolatileTest_Unsafe {
    private static volatile int vol = 0;

    public static void increse() {
        vol++;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    increse();
                }
            }).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(vol);
    }
}

上面程序的答案并不是100,000，对increse加上synchronized修饰，或者使用原子类都可以解决这个问题：

/**
 * @Author Joy
 * @Date 2021/8/28
 * @Desc 原子类保证线程安全
 */
public class AtomicIntegerTest_Safe {
    private static AtomicInteger atomic = new AtomicInteger(0);

    public static void increse() {
        atomic.getAndIncrement();
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    increse();
                }
            }).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(atomic);
    } 
}

解释下 while (Thread.activeCount() > 2)这行，它的作用是等待主线程外的线程都结束，但是在IDEA中运行的话，如果是 RUN 需要改成2，如果是 DEBUG 就是1。

因为最后除了 main 线程，在 IDEA 里还会存在一个Monitor Ctrl-Break 的线程，它使用了 socket 来监控 IDEA 的命令。

感兴趣的可以看下：https://blog.lzys.cc/p/2124223.html