JUC(10) volatile与JMM

2024-01-09 01:00:39 # Language # Java

1. 被volatile修饰的变量有两大特点

特点：
- 可见性
- 有序性：有排序要求，有时需要禁止指令重排
  - 不存在数据依赖关系可以重排，否则禁重排，重排后的指令也不能改变原有串行语义
内存语义：
- 当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值立即刷新回主内存中
- 当读一个volatile变量时，JMM会把该线程对应的本地内存设置为无效，重新回到主内存中读取最新共享变量的值
- 例如如果通过嗅探一个处理器来检测其他处理器打算写内存地址，而这个地址当前处于共享状态，那么正在嗅探的处理器将使它的缓存行无效，在下次访问相同内存地址时，强制执行缓存行填充。
volatile凭什么可以保证可见性和有序性？
- 内存屏障 Memory Barrier

2. 内存屏障

2.1 概念

内存屏障（也称内存栅栏，屏障指令等）是一类同步屏障指令，是CPU或编译器在对内存随机访问的操作中的一个同步点，使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作，避免代码重排序。内存屏障其实就是一种JVM指令，Java内存模型的重排规则会要求Java编译器在生成JVM指令时插入特定的内存屏障指令，通过这些内存屏障指令，volatile实现了Java内存模型中的可见性和有序性（禁重排），但volatile无法保证原子性

内存屏障之前的所有写操作都要回写到主内存
内存屏障之后的所有读操作都能获得内存屏障之前的所有写操作的最新结果（实现了可见性）

写屏障(Store Memory Barrier)：告诉处理器在写屏障之前将所有存储在缓存(store buffers)中的数据同步到主内存，也就是说当看到Store屏障指令，就必须把该指令之前的所有写入指令执行完毕才能继续往下执行

读屏障(Load Memory Barrier)：处理器在读屏障之后的读操作，都在读屏障之后执行。也就是说在Load屏障指令之后就能够保证后面的读取数据指令一定能够读取到最新的数据。

因此重排序时，不允许把内存屏障之后的指令重排序到内存屏障之前。一句话：对一个volatile变量的写，先行发生于任意后续对这个volatile变量的读，也叫写后读

2.2 分类

粗分两种：

读屏障（Load Barrier）：在读指令之前插入读屏障，让工作内存或CPU高速缓存当中的缓存数据失效，重新回到主内存中获取最新数据。
写屏障（Store Barrier）：在写指令之后插入写屏障，强制把缓冲区的数据刷回到主内存中。

细分四种：

屏障类型	指令示例	说明
`LoadLoad`	Load1; LoadLoad; Load2;	保证Load1的读取操作在Load2及后续读取操作之前执行
`StoreStore`	Store1; StoreStore; Store2;	在store2及其后的写操作执行前，保证Store1的写操作已经刷新到主内存
`LoadStore`	Load1; LoadStore; Store2;	在Store2及其后的写操作执行前，保证Load1的读操作已经结束
`StoreLoad`	Store1; StoreLoad; Load2;	保证Store1的写操作已经刷新到主内存后，Load2及其后的读操作才能执行

2.3 详解

如何保证有序性

通过内存屏障禁止重排

重排序有可能影响程序的执行和实现，因此，我们有时候希望告诉JVM别自动重排序，我这里不需要重排序，一切听我的。
对于编译器的重排序，JMM会根据重排序的规则，禁止特定类型的编译器重排序
对于处理器的重排序，Java编译器在生成指令序列的适当位置，插入内存屏障指令，来禁止特定类型的处理器排序。

JMM 针对编译器制定的 volatile 重排序规则表

当第一个操作为volatile读时，不论第二个操作是什么，都不能重排序，这个操作保证了volatile读之后的操作不会被重排到volatile读之前。
当第二个操作为volatile写时，不论第一个操作是什么，都不能重排序，这个操作保证了volatile写之前的操作不会被重排到volatile写之后
当第一个操作为volatile写时，第二个操作为volatile读时，不能重排

JMM 将内存屏障插入策略分为 4 种规则

为了实现 volatile 的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。对于编译器来说，发现一个最优布置来最小化插入屏障的总数几乎不可能。为此，JMM 采取保守策略。下面是基于保守策略的 JMM 内存屏障插入策略。

读屏障：在每个volatile读操作的后面插入一个LoadLoad屏障和一个LoadStore屏障
写屏障：在每个volatile写操作的前面插入StoreStore屏障；在每个volatile写操作的后面插入StoreLoad屏障；

上述内存屏障插入策略非常保守，但它可以保证在任意处理器平台，任意的程序中都能得到正确的 volatile 内存语义。

3. volatile特性

3.1 保证可见性

保证不同线程对某个变量完成操作后结果及时可见，即该共享变量一旦改变所有线程立即可见

/**
 * 不加volatile，没有可见性，程序无法停止
 * 加了volatile，保证可见性，程序可以停止
 */
public class VolatileSeeDemo {

    /**
     * t1	-------come in
     * main	 修改完成
     * t1	-------flag被设置为false，程序停止
     */
    static volatile boolean flag = true;

    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t-------come in");
            while (flag) {}
            System.out.println(Thread.currentThread().getName() + "\t-------flag被设置为false，程序停止");
        }, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //更新flag值
        flag = false;
        System.out.println(Thread.currentThread().getName() + "\t 修改完成");
    }
}

volatile变量的读写过程

read: 作用于主内存，将变量的值从主内存传输到工作内存，主内存到工作内存.
load: 作用于工作内存，将read从主内存传输的变量值放入工作内存变量副本中，即数据加载
use: 作用于工作内存，将工作内存变量副本的值传递给执行引擎，每当JVM遇到需要该变量的字节码指令时会执行该操作
assign: 作用于工作内存，将从执行引擎接收到的值赋值给工作内存变量，每当JVM遇到一个给变量赋值字节码指令时会执行该操作
store: 作用于工作内存，将赋值完毕的工作变量的值传送到主内存
write: 作用于主内存，将store传输过来的变量值赋值给主内存中的变量

由于上述 6 条只能保证单条指令的原子性，针对多条指令的组合性原子保证，JVM提供了另外两个原子指令:

lock: 作用于主内存，将一个变量标记为一个线程独占的状态，只是写时候加锁，就只是锁了写变量的过程。
unlock: 作用于主内存，把一个处于锁定状态的变量释放，然后才能被其他线程占用

3.2 没有原子性

volatile变量的复合操作不具有原子性，比如number++

public class VolatileNoAtomicTest {
    public static void main(String[] args) {
        Number number = new Number();
        for (int i=0;i<10;i++){
            new Thread(()->{
                for(int j=0;j<1000;j++){
                    number.add();
                }
            }).start();
        }
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(number.number);
    }
   static class Number{
        private volatile  int number;
        public void add(){
            number++;
        }
    }
}
// 在不给方法加锁的情况下，仅仅凭借volatile 修饰无法保证线程安全，最终的值也不是10000

对于 volatile 变量具备可见性，JVM 只是保证从主内存加载到线程工作内存的值是最新的，也仅仅是数据加载时是最新的。但是多线程环境下，“数据计算”和“数据赋值”操作可能多次出现，若数据在加载之后，若主内存 volatile 修饰变量发生修改之后，线程工作内存的操作将会作废去读主内存最新值，操作出现写丢失问题。即各线程私有内存和主内存公共内存中变量不同步，进而导致数据不一致。由此可见 volatile 解决的是变量读时的可见性问题，但无法保证原子性，对于多线程修改主内存共享变量的场景必须加锁同步。

原子性指的是一个操作是不可中断的，即使是在多线程环境下，一个操作一旦开始就不会被其他线程影响。i++ 不具备原子性，该操作是先读取值，然后写回一个新值，分 3 步完成。如果第二个线程在第一个线程读取旧值和写回新值期间读取 i 的域值，那么第二个线程就会与第一个线程一起看到同一个值，并执行相同值的加 1 操作，这也就造成了线程安全失败，因此对于 add 方法必须使用 synchronized 修饰以便保证线程安全

volatile变量不适合参与到依赖当前值的运算

3.3 指令禁重排

重排序

重排序是指编译器和处理器为了犹化程序性能而对指令序列进行重新排序的一种手段，有时候会改变程序语句的先后顺序

不存在数据依赖关系，可以重排序;
存在数据依赖关系，禁止重排序

但重排后的指令绝对不能改变原有的串行语义!这点在并发设计中必须要重点考虑!

重排序的分类和执行流程

编译器优化的重排序: 编译器在不改变单线程中行语义的前提下，可以重新调整指令的执行顺序
指令级并行的重排序: 处理器使用指令级并行技术来讲多条指令重叠执行，若不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序
内存系统的重排序: 由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是乱序执行

数据依赖性: 若两个操作访问同一变量，且这两个操作中有一个为写操作，此时两操作间就存在数据依赖性

但不同处理器和不同线程之间的数据性不会被编译器和处理器考虑，其只会作用于单处理器和单线程环境

下面三种情况，只要重排序两个操作的执行次序，程序的执行结果就会被改变

写后读、写后写、读后写

volatile有关的禁止指令重排行为与四大屏障的插入情况

详见 2.3

代码说明

public class VolatileTest{
    int i = 0;
    volatile boolean flag = false;
    public void write() { // 线程 A 运行
        i = 2;
    	flag = true;
    }
    public void read() { // 线程 B 运行
        if(flag) {
            System.out.println("i = " + i);
        }
    }
}

如果 flag 没有被 volatile 修饰，且 i 和 flag 没有数据依赖性，假如 write 方法中发生了指令重排，可能导致 i 没有被赋值就被 read 打印

4. 如何正确使用volatile

单一赋值可以，但是含复合运算赋值不可以（i++之类）

状态标志，判断业务是否结束

作为一个布尔状态标志，用于指示发生了一个重要的一次性事件，例如完成初始化或任务结束

开销较低的读，写锁策略

当读远多于写，结合使用内部锁和volatile变量来减少同步的开销
原理是：利用volatile保证读操作的可见性，利用synchronized保证符合操作的原子性

DCL双端锁的发布

实例化对象时会分为三步：
1. 分配对象内存空间
2. 初始化对象
3. 设置 instance 指向刚分配的内存地址
多线程环境下，在实例化对象时，由于重排序导致 2，3 乱序，即先分配地址再初始化，后果就是其他线程可能会获得一个未完全初始化的实例
要通过 volatile 声明来实现线程安全的延迟初始化

5. 小总结

volatile可见性

写操作的话，这个变量的最新值会立即刷新回到主内存中
读操作的话，总是能够读取到这个变量的最新值，也就是这个变量最后被修改的值
当某个线程收到通知，去读取volatile修饰的变量的值的时候，线程私有工作内存的数据失效，需要重新回到主内存中去读取最新的数据。

在 volatile 修饰的共享变量进行写操作的时候会多出 lock 前缀的指令

lock 前缀的指令在多核处理器下会引发两件事情:

将当前处理器缓存行的数据写回到系统内存。

写回内存的操作会使在其他 CPU 里缓存了该内存地址的数据无效。

为了保证各个处理器的缓存是一致的，实现了缓存一致性协议(MESI)，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存里。

所有多核处理器下还会完成：当处理器发现本地缓存失效后，就会从内存中重读该变量数据，即可以获取当前最新值。

volatile 变量通过这样的机制就使得每个线程都能获得该变量的最新值。

volatile没有原子性

volatile禁重排