第七章：volatile与JMM

鲨瓜2号

已于 2022-12-29 12:24:12 修改

阅读量106

点赞数

分类专栏： # JUC高级文章标签： jvm java

于 2022-11-26 21:54:24 首次发布

本文链接：https://blog.csdn.net/aetawt/article/details/128057900

版权

JUC高级专栏收录该内容

14 篇文章 0 订阅

订阅专栏

被volatile修改的变量有2大特点
volatile 的内存语义
内存屏障（面试重点）
- 内存屏障是什么？
- 内存屏障的分类
happens-before之volatile变量规则
四大屏障的插入情况
- volatile读
- volatile 写
volatile可见性
- volatile 变量的读写过程
volatile 不具备原子性
volatile 指令禁重排
volatile 的使用场景
总结

被volatile修改的变量有2大特点

可见性
- 写完后立即刷新会主内存并及时发出通知，其他线程可以去主内存中拿去新的值，前面的修改对后面所有线程可见
有序性（禁重排）
- 重排序是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段，有时候会改变程序语句的先后顺序
- 不存在数据依赖关系，可以重排序;
- 存在数据依赖关系，禁止重排序
- 但重排后的指令绝对不能改变原有的串行语义! 这点在并发设计中必须要重点考虑!

volatile 并不保证原子性

volatile 的内存语义

当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量立即刷新回到主内存中。

当读一个volatile变量时，JMM会把该线程对应的工作内存设置为无效，直接从主内存中读取共享变量。

所以 volatile 的写内存语义是直接刷新到主内存中，读的内存语义是直接从主内存中读取。

volatile 为什么能够保证可见性和有序性呢？它靠的就是内存屏障

内存屏障（面试重点）

先看一下生活中的例子

即使标语中写出请勿滞留，请靠右行… 但是却没有什么用。没有管控，顺序难保。再看下一张图：

武警就相当于一层屏障，阻断这人们

内存屏障是什么？

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

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

内存屏障的分类

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

在写指令之后插入写屏障，强制把写缓冲区的数据刷回到主内存中

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

在读指令之前插入读屏障，让工作内存或CPU高速缓存当中的缓存数据失效，重新回到主内存中获取最新数据。

在这里插入图片描述

因此重排序时，不允许把内存屏障之后的指令重排序到内存屏障之前。
一句话：对一个 volatile 域的写, happens-before 于任意后续对这个 volatile 域的读，也叫写后读。

细分四大屏障指令：

对应底层C源码：

happens-before之volatile变量规则

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

四大屏障的插入情况

volatile读

当线程正在 volatile读的时候，不管其后面的操作是啥，你都得等我读完了再说。

volatile 写

在线程 volatile 写的时候，不管前面有读/写还是后面有 volatile读/写，都不允许与volatile写重排序

volatile可见性

volatile 可见性：某个线程修改被 volatile 修饰的变量值之后，这个新值对于其他线程来说是立即可见的。volatile 会强制将修改的值写入主内存中

通过代码演示：

希望在主线程中修改 flag 的值后，t1 线程立即停止

public class volatileTest {
    static  boolean flag = true;
    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " come in...");
            while (flag) {
                
            }
            System.out.println(" flag 被修改为 false，程序结束...");
        }, "t1").start();

        try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}
        flag = false;
        System.out.println(Thread.currentThread().getName() + " 修改了flag为false");
    }
}

结果：

当主线程修改 flag 的值，t1线程并没有停止，原因有以下俩个：

主线程修改了flag之后没有将其刷新到主内存，所以t1线程看不到。
主线程将flag刷新到了主内存，但是t1一直读取的是自己工作内存中flag的值，没有去主内存中更新获取flag最新的值。

我们的诉求：

线程中修改了工作内存中的副本之后，立即将其刷新到主内存；
工作内存中每次读取共享变量时，都去主内存中重新读取，然后拷贝到工作内存。

解决：

使用volatile修饰共享变量，就可以达到上面的效果，被volatile修改的变量有以下特点：

线程中读取的时候，每次读取都会去主内存中读取共享变量最新的值，然后将其复制到工作内存
线程中修改了工作内存中变量的副本，修改之后会立即刷新到主内存

volatile 变量的读写过程

read(读取)→load(加载)→use(使用)→assign(赋值)→store(存储)→write(写入)→lock(锁定)→unlock(解锁)

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

由于上述6条只能保证单条指令的原子性，针对多条指令的组合性原子保证，没有大面积加锁，所以，JVM提供了另外两个原子指令：

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

volatile 不具备原子性

被 volatile 修饰的变量的复合操作是不具备原子性的，比如：i++

代码演示：

创建十个线程，分别执行1000 次 i++ 操作，预计中的结果为：10000

public class VolatileNotAtomicTest {
   static  volatile  int i = 0 ;
    public static  void add() {
        i++;
    }
    public static  void main(String[] args) {
        for (int i1 = 0; i1 < 10; i1++) {
            new Thread(() -> {
                for (int i2 = 1; i2 <= 1000; i2++) {
                    add();
                }
            }, String.valueOf(i1)).start();
        }
        try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println(Thread.currentThread().getName() + "获取值: " + i);
    }
}

输出结果：

main获取值: 9412

因此我们得出的结论就是： volatile 修饰的变量进行复合操作时是不保证原子性的。

简单的 i++ 操作在代码层面看只有短短一行代码，但是我们可以通过字节码的角度看，i++ 的一行代码，jvm 要做多少事情：

从字节码的角度可以看出，简单的一行i++ 他会执行以下三步：

数据加载：获取 i 变量的值，并压入操作数栈
数据计算：将常量 1 压入操作数栈，并将 i 变量的值和 1 相加。
数据赋值：弹出计算完成的值并返回。

也就是说，这三个操作之间是有时间间隙的，在这个间隙之间很有可能就会有其他线程同时对变量 i 进行自增操作。下面我举一个例子，比如 i = 0 时：

线程 1 先读取 i 的值为0，并没有进行修改。这时线程 1 由于一些原因被阻塞。
此时线程 2 获取 i 的值，由于线程 1 并没有对 i 变量进行修改操作，因此线程 2读取到的值还是 0，执行自增操作，最后将1成功写入主存。
而在线程 2 自增完后，线程 1中本地内存的值仍然为 0，执行自增操作后值为 1，最后存入主存。

因此在执行俩次 i++ 操作之后，而 i 的实际值只增加了 1。

疑问一：说到这里，有人可能会说，在上面的 变量读写过程 中，不是对变量上锁了嘛，并且在上锁后会清空其他线程工作内存的值啊？

说的是没错，但是各位在仔细看看在线程 1 读取变量的时候，并没有对其修改的时候就已经被阻塞。因此也就不存在清空工作内存中的变量值的情况。虽然能够保证线程 2 也是从主内存中读取的值，但是此时线程2读取时，线程 1 根本就还没有写回主内存，线程 2 读取到的值仍然是0。

疑问二：有人可能会说，在线程二写入主内存的时候，由于 volatile 的内存可见性，此时线程1 的值不应该是 1 吗？

线程2写入主存时，线程 1 已经从主存中读取过值，有一种可见性迟到的感觉。

结论：

volatile不适合参与到依赖当前值的运算，如i=i+1，i++之类的
通常volatile用作保存某个状态的boolean值或or int值。（一旦布尔值被改变迅速被看到，就可以做其他操作）

因此对于修改主内存中变量的场景中，必须使用加锁的方式来保证原子性。

volatile 指令禁重排

重排序

重排序是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段，有时候会改变程序语句的先后顺序。 但重排后的指令绝对不能改变原有的串行语义！这点在并发设计中必须要重点考虑！

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

重排序的分类和流程：

编译器优化的重排序：编译器在不改变单线程串行语义的前提下，可以重新调整指令的执行顺序
指令级并行的重排序：处理器使用指令级并行技术来讲多条指令重叠执行，若不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序

内存系统的重排序：由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是乱序执行

案例一：

int a = 1; // 语句一
int b= 20; // 语句二
int c = a + b ; // 语句三

----------------------------------重排后
int b= 20; 
int a = 1; 
int c = a + b ;

此时语句一和语句二重排后，结果并不会改变，因此就允许重排

案例二：

以下代码的情况，只要代码顺序发生变化，执行结果就会改变，因此不允许指令重排

案例三：

如果 flag 没有加 volatile 关键字，那么在 write 写中，i =2 就有可能和flag=true 进行重排，调换顺序。

这样一来，最终的执行结果就有可能发生变化。因此需要加上 volatile 禁止指令重排序

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

加入 volatile 后，内存屏障的插入情况：

volatile 写：

volatile 读：

volatile 的使用场景

单一赋值可以，但是含有复合运算不可以
使用状态标志，比如：判断业务是否结束

//这个前面讲过
public class UseVolatileDemo
{
    private volatile static boolean flag = true;

    public static void main(String[] args)
    {
        new Thread(() -> {
            while(flag) {
                //do something......循环
            }
        },"t1").start();

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(2L); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            flag = false;
        },"t2").start();
    }
}

开销较低的读，写锁策略

public class UseVolatileDemo
{
    //
   // 使用：当读远多于写，结合使用内部锁和 volatile 变量来减少同步的开销
   // 理由：利用volatile保证读取操作的可见性；利用synchronized保证复合操作的原子性
     
    public class Counter
    {
        private volatile int value;

        public int getValue()
        {
            return value;   //利用volatile保证读取操作的可见性
              }
        public synchronized int increment()
        {
            return value++; //利用synchronized保证复合操作的原子性
               }
    }
}

DCL 双端锁的发布

public class SafeDoubleCheckSingleton
{
    private static SafeDoubleCheckSingleton singleton; //-----这里没加volatile
    //私有化构造方法
    private SafeDoubleCheckSingleton(){
    }
    //双重锁设计
    public static SafeDoubleCheckSingleton getInstance(){
        if (singleton == null){
            //1.多线程并发创建对象时，会通过加锁保证只有一个线程能创建对象
            synchronized (SafeDoubleCheckSingleton.class){
                if (singleton == null){
                    //隐患：多线程环境下，由于重排序，该对象可能还未完成初始化就被其他线程读取
                    singleton = new SafeDoubleCheckSingleton();
                    //实例化分为三步
                    //1.分配对象的内存空间
                    //2.初始化对象
                    //3.设置对象指向分配的内存地址
                }
            }
        }
        //2.对象创建完毕，执行getInstance()将不需要获取锁，直接返回创建对象
        return singleton;
    }
}

单线程环境下(或者说正常情况下)，在"问题代码处"，会执行如下操作，保证能获取到已完成初始化的实例

//三步
memory = allocate(); //1.分配对象的内存空间
ctorInstance(memory); //2.初始化对象
instance = memory; //3.设置对象指向分配的内存地址

隐患：多线程环境下，在"问题代码处"，会执行如下操作，由于重排序导致2,3乱序，后果就是其他线程得到的是null而不是完成初始化的对象 。（没初始化完的就是null）

//三步
memory = allocate(); //1.分配对象的内存空间
ctorInstance(memory); //2.初始化对象
instance = memory; //3.设置对象指向分配的内存地址

---------------------------------------------------------- 非正常情况

//三步
memory = allocate(); //1.分配对象的内存空间
instance = memory; //3.设置对象指向分配的内存地址---这里指令重排了，但是对象还没有初始化
ctorInstance(memory); //2.初始化对象

实例化singleton分多步执行（分配内存空间、初始化对象、将对象指向分配的内存空间），某些编译器为了性能原因，会将第二步和第三步进行重排序（分配内存空间、将对象指向分配的内存空间、初始化对象）。这样，某个线程可能会获得一个未完全初始化的实例。

解决：加 volatile

public class SafeDoubleCheckSingleton
{
    //通过volatile声明，实现线程安全的延迟初始化。
    private volatile static SafeDoubleCheckSingleton singleton;
    //私有化构造方法
    private SafeDoubleCheckSingleton(){
    }
    //双重锁设计
    public static SafeDoubleCheckSingleton getInstance(){
        if (singleton == null){
            //1.多线程并发创建对象时，会通过加锁保证只有一个线程能创建对象
            synchronized (SafeDoubleCheckSingleton.class){
                if (singleton == null){
                    //隐患：多线程环境下，由于重排序，该对象可能还未完成初始化就被其他线程读取
                                      //原理:利用volatile，禁止 "初始化对象"(2) 和 "设置singleton指向内存空间"(3) 的重排序
                    singleton = new SafeDoubleCheckSingleton();
                }
            }
        }
        //2.对象创建完毕，执行getInstance()将不需要获取锁，直接返回创建对象
        return singleton;
    }
}

总结

被 volatile 修饰的变量，具有了以下特征：可见性、禁排序、不能保证原子性

volatile 可见性

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

不能保证原子性

禁止指令重排序

volatile 写：

volatile 读：

volatile 是如何和内存屏障相关联的？

内存屏障是什么？

内存屏障是一种屏障指令，它使得CPU或编译器对屏障指令的前和后所发出的内存操作执行一个排序的约束。也叫内存栅栏或栅栏指令

内存屏障能干嘛？

阻止屏障两边的指令重排序
写数据时假如屏障，强制将线程私有工作内存的数据刷回主物理内存
读数据时加入屏障，线程私有工作内存的数据失效，重新到主物理内存中获取最新数据

内存屏障的四大指令：

volatile写之前的的操作，都禁止重排到volatile之后
volatile读之后的操作，都禁止重排到volatile之前
volatile写之后volatile读，禁止重排序

各位彭于晏，如有收获点个赞不过分吧…✌✌✌

Alt

鲨瓜2号

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
第七章：volatile与JMM

被 volatile 修饰的变量，具有了以下特征：可见性、禁排序、不能保证原子性volatile 可见性写操作的话，这个变量的最新值会立即刷新回到主内存中读操作的话，总是能够读取到这个变量的最新值，也就是这个变量最后被修改的值当某个线程收到通知，去读取volatile修饰的变量的值的时候，线程私有工作内存的数据失效，需要重新回到主内存中去读取最新的数据。不能保证原子性禁止指令重排序volatile 写volatile 读volatile 是如何和内存屏障相关联的？内存屏障是什么？
复制链接

扫一扫