JMM与volatile

恨不相逢未涨时

已于 2023-01-15 18:33:58 修改

阅读量664

点赞数 1

分类专栏： # 多线程与并发文章标签： volatile 可见性禁止指令重排序内存屏障原子性

于 2022-10-23 22:57:52 首次发布

本文链接：https://blog.csdn.net/qq_44300280/article/details/127476199

版权

多线程与并发专栏收录该内容

13 篇文章 54 订阅

订阅专栏

文章目录

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

可见性
写完后立即刷新回主内存并及时发出通知，大家可以去主内存拿最新版，前面的修改对后面所有线程可见

有序性（禁止指令重排序）
重排序是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段，有时候会改变程序语句的先后顺序
不存在数据依赖关系，可以重排序;存在数据依赖关系，禁止重排序
但重排后的指令绝对不能改变原有的串行语义!这点在并发设计中必须要重点考虑!

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

2. volatile的内存语义

当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值立即刷新回主内存中。.
当读一个volatile变量时，JMM会把该线程对应的本地内存设置为无效，重新回到主内存中读取最新共享变量
所以volatile的写内存语义是直接刷新到主内存中，读的内存语义是直接从主内存中读取。

3. 内存屏障(面试重点必须拿下）

volatile凭什么可以保证可见性和有序性?
凭借的是：内存屏障Memory Barrier

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

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

写屏障 (Store Memory Barrier) :告诉处理器在写屏障之前将所有存储在缓存(store bufferes)中的数据同步到主内存。也就是
说当看到Store屏障指令，就必须把该指令之前所有写入指令执行完毕才能继续往下执行。
读屏障(Load Memory Barrier):处理器在读屏障之后的读操作，都在读屏障之后执行。也就是说在Load屏障指令之后就能够保证后面的读取数据指令一定能够读取到最新的数据。

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

内存屏障分类
粗分两类：
读屏障(LoadBarrier)：在读指令之前插入读屏障，让工作内存或CPU高速缓存当中的缓存数据失效，重新回到主内存中获取最新数据
写屏障(StoreBarrier)：在写指令之后插入写屏障，强制把写缓冲区的数据刷回到主内存中

细分四类：
在这里插入图片描述 native方法，底层调用C++实现

happens-before之volatile 变量规则
在这里插入图片描述
JMM就将内存屏障插入策略分为4种规则
读屏障：
在每个volatile读操作的后面插入一个LoadLoad屏障
在每个volatile读操作的后面插入一个LoadStore屏障

volatile读插入内存屏障后生成的指令序列示意图
在这里插入图片描述写屏障
在每个volatile写操作的前面插入一个StoreStore屏障
在每个volatile写操作的后面插入一个StoreLoad屏障

volatile写插入内存屏障后生成的指令序列示意图
在这里插入图片描述

4. volatile特性

保证可见性

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

public class VolatileTest {
    static volatile boolean flag=true;
    public static void main(String[] args) {
        new Thread(()->{
            System.out.println("flag值："+flag);
            while (flag){

            }
            System.out.println("flag值被修改："+flag);
        },"t1").start();
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag=false;
        System.out.println("flag值被main修改："+flag);
    }
}

不加Ivolatile，没有可见性，程序无法停止
加了volatile，保证可见性，程序可以停止

线程t1中为何看不到被主线程main修改为false的flag的值?
问题可能:
1）主线程修改了flag之后没有将其刷新到主内存，所以t1线程看不到。
2）主线程将flag刷新到了主内存，但是t1一直读取的是自己工作内存中flag的值，没有去主内存中更新获取flag最新的值。
我们的诉求:
1）线程中修改了自己工作内存中的副本之后，立即将其刷新到主内存;
2）工作内存中每次读取共享变量时，都去主内存中重新读取，然后拷贝到工作内存。
解决:
使用volatile修饰共享变量，就可以达到上面的效果，被volatile修改的变量有以下特点:
1）线程中读取的时候，每次读取都会去主内存中读取共享变量最新的值，然后将其复制到工作内存
2）线程中修改了工作内存中变量的副本，修改之后会立即刷新到主内存

在这里插入图片描述 read:作用于主内存，将变量的值从主内存传输到工作内存，主内存到工作内存.
load:作用于工作内存，将read从主内存传输的变量值放入工作内存变量副本中，即数据加载
use:作用于工作内存，将工作内存变量副本的值传递给执行引擎，每当JVM遇到需要该变量的字节码指令时会执行该操作
assign:作用于工作内存，将从执行引擎接收到的值赋值给工作内存变量，每当JVM遇到一个给变量赋值字节码指令时会执行该操作
store:作用于工作内存，将赋值完毕的工作变量的值写回给主内存
write:作用于主内存，将store传输过来的变量值赋值给主内存中的变量
由于上述6条只能保证单条指令的原子性，针对多条指令的组合性原子保证，没有大面积加锁,所以，JVM提供了另外两个原子指令:
lock:作用于主内存，将一个变量标记为一个线程独占的状态，只是写时候加锁，就只是锁了写变量的过程。
unlock:作用于主内存，把一个处于锁定状态的变量释放，然后才能被其他线程占用

没有原子性

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

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

volatile变量不适合参与到依赖当前值的运算，如i=i+1; i++;之类的。那么依靠可见性的特点volatile可以用在哪些地方呢?通常volatile用做保存某个状态的boolean值or int值。《深入理解Java虚拟机》提到:由于volatile变量只能保证可见性，在不符合以下两条规则的运算场景中，我们仍然要通过加锁(使用synchronized、java.util.concurrent中的锁或原子类)来保证原子性:
1）运算结果并不依赖变量的当前值，或者能够确保只有单一的线程修改变量的值。
2）变量不需要与其他的状态变量共同参与不变约束。

JVM的字节码，i++分成三步，间隙期不同步非原子操作(i++)
对于volatile变量，JVM只是保证从主内存加载到线程工作内存的值是最新的，也只是数据加载时是最新的。
如果第二个线程在第一个线程读取旧值和写回新值期间读取i的域值，也就造成了线程安全问题。

指令禁重排

在这里插入图片描述
在每一个volatile写操作前面插入一个StoreStore屏障
StoreStore屏障可以保证在volatile写之前，其前面的所有普通写操作都已经刷新到主内存
在每一个volatile写操作后面插入一个StoreLoad屏障
StoreLoad屏障的作用是避免volatile写与后面可能有的volatile读/写操作重排序

在每一个volatile读操作后面插入一个LoadLoad屏障
LoadLoad屏障用来禁止处理器把上面的volatile读与下面的普通读重排序。
在每一个volatile读操作后面插入一个LoadStore屏障
LoadStore屏障用来禁止处理器把上面的volatile读与下面的普通写重排序。

5. volatile的使用场景

单一赋值可以，含复合运算赋值不可以(i++之类)
volatile int a=10
volatile boolean flag=false
状态标志，判断业务是否结束
在这里插入图片描述开销较低的读，写锁策略
DCL双端检锁
其中第3步中实例化Singleton分多步执行(分配内存空间、初始化对象、将对象指向分配的内存空间)，某些编译器为了性能原因，会将第二步和第三步进行重排序(分配内存空间、将对象指向分配的内存空间、初始化对象)。这样，某个线程可能会获得一个未完全初始化的实例。

嗅探机制和缓存一致性协议通知其他线程主内存的值已经被改。

6. 面试总结

在这里插入图片描述可见性
禁重排写指令
禁重排读指令
凭什么我们java写了一个volatile关键字系统底层加入内存屏障?两者关系怎么勾搭上的?
内存屏障:是一种屏障指令，它使得CPU或编译器对屏障指令的前和后所发出的内存操作执行一个排序的约束。也叫内存栅栏或栅栏指令
在这里插入图片描述三句话总结
volatile 写之前的操作，都禁止重排序到volatile之后
volatile 读之后的操作，都禁止重排序到 volatile之前
volatile写之后volatile读，禁止重排序