JUC并发编程与源码分析笔记07-volatile与JMM

最新推荐文章于 2024-08-06 22:13:24 发布

王劭阳

最新推荐文章于 2024-08-06 22:13:24 发布

阅读量479

点赞数

分类专栏： JUC并发编程与源码分析文章标签： JUC

本文链接：https://blog.csdn.net/qq_36059561/article/details/128178754

版权

JUC并发编程与源码分析专栏收录该内容

15 篇文章 4 订阅

订阅专栏

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

可见性、有序性，但是不保证原子性。
当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值立即刷新回主内存中。当读一个volatile变量时，JMM会把该线程对应的本地内存设置为无效，重新回到主内存中读取最新共享变量，所以volatile的写内存语义是直接刷新到主内存中，读的内存语义是直接从主内存中读取。
volatile凭什么可以保证可见性和有序性？内存屏障Memory Barrier。

内存屏障

是什么

内存屏障（也称内存栅栏，屏障指令等，是一类同步屏障指令，是CPU或编译器在对内存随机访问的操作中的一个同步点，使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作），避免代码重排序。内存屏障其实就是一种JVM指令，Java内存模型的重排规则会要求Java编译器在生成JVM指令时插入特定的内存屏障指令，通过这些内存屏障指令，volatile实现了Java内存模型中的可见性和有序性（禁重排），但volatile无法保证原子性。
内存屏障之前的所有写操作都要回写到主内存，内存屏障之后的所有读操作都能获得内存屏障之前的所有写操作的最新结果（实现了可见性）。
写屏障（Store Memory Barrier）：告诉处理器在写屏障之前将所有存储在缓存（Store Bufferes）中的数据同步到主内存。也就是说当看到Store屏障指令，就必须把该指令之前所有写入指令执行完毕才能继续往下执行。
读屏障（Load Memory Barrier）：处理器在读屏障之后的读操作，都在读屏障之后执行。也就是说在Load屏障指令之后就能够保证后面的读取数据指令一定能够读取到最新的数据。
因此重排序时，不允许把内存屏障之后的指令重排序到内存屏障之前。一句话：对一个volatile变量的写，先行发生于任意后续对这个volatile变量的读，也叫写后读。

内存屏障分类

粗分类

读屏障（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及其后的读操作才能执行

禁重排

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

happens-before之volatile变量规则

第一个操作	第二个操作：普通读写	第二个操作：volatile读	第二个操作：volatile写
普通读写	可以重排	可以重排	不可以重排
volatile读	不可以重排	不可以重排	不可以重排
volatile写	可以重排	不可以重排	不可以重排

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

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

读屏障

在每个volatile读操作后面插入一个LoadLoad操作
在每个volatile读操作后面插入一个LoadStore操作
在这里插入图片描述

写屏障

在每个volatile写操作前面插入一个StoreStore屏障
在每个volatile写操作后面插入一个StoreLoad屏障
在这里插入图片描述

volatile特性

保证可见性

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

public class JMMDemo {
    static volatile boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (flag) {
            }
            System.out.println(Thread.currentThread().getName() + "停止");
        }, "MyThread").start();
        Thread.sleep(1000);
        flag = false;
        System.out.println(Thread.currentThread().getName() + "：flag=" + flag);
    }
}

尝试把flag变量的volatile去掉，再运行，发现子线程是不能停止的。因为子线程拿不到主线程对flag变量修改后的值。
这里还发现了一个问题，flag不使用volatile修饰，但是在while(flag)循环体里加System.out.println，也可以实现效果，这是因为println方法是带synchronized锁的，synchronized要保证可见性，就会去主内存拉取一份最新的数据，也就是同步flag的值，此时，flag的值被更新，子线程停止。
使用volatile修饰共享变量，就可以达到上面的效果，被volatile修饰的变量有以下特点：

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

没有原子性

先看一段代码，运行一下，看看能不能得到想要的结果。

public class JMMDemo {
    static volatile int count = 0;

    public static void main(String[] args) throws InterruptedException {
        System.out.println("count=" + count);
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    count++;
                }
            }, "Thread-" + i).start();
        }
        Thread.sleep(2000);
        System.out.println(count);
    }
}

运行之后，并没有得到想要的结果。
对于volatile变量具备可见性，JVM只是保证从主内存加载到线程工作内存的值是最新的，也仅是数据加载时是最新的。但是多线程环境下，“数据计算”和“数据赋值”操作可能多次出现，若数据在加载之后，若主内存volatile修饰变量发生修改之后，线程工作内存中的操作将会作废去读主内存最新值，操作出现写丢失问题。即各线程私有内存和主内存公共内存中变量不同步，进而导致数据不一致。由此可见volatile解决的是变量读时的可见性问题，但无法保证原子性，对于多线程修改主内存共享变量的场景必须使用加锁同步。
volatile变量不适合参与到依赖当前值的运算：如i = i + 1，i++之类的。

指令禁重排

重排序是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段，有时候会改变程序语句的先后顺序不存在数据依赖关系，可以重排序；存在数据依赖关系，禁止重排序。但重排后的指令绝对不能改变原有的串行语义！这点在并发设计中必须要重点考虑！
重排序的分类和执行流程：源代码→编译器优化重排序→指令级并行重排序→内存系统重排序→最终执行的指令序列。
编译器优化的重排序：编译器在不改变单线程串行语义的前提下，可以重新调整指令的执行顺序。
指令级并行的重排序：处理器使用指令级并行技术来讲多条指令重叠执行，若不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
内存系统的重排序：由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是乱序执行。
若存在数据依赖关系，禁止重排序→重排序发生，会导致程序运行结果不同。
编译器和处理器在重排序时，会遵守数据依赖性，不会改变存在依赖关系的两个操作的执行，但不同处理器和不同线程之间的数据性不会被编译器和处理器考虑，其只会作用于单处理器和单线程环境，下面三种情况，只要重排序两个操作的执行顺序，程序的执行结果就会被改变。

名称	代码示例
写后读	a=1;b=a;
写后写	a=1;a=2;
读后写	a=b;b=1;

如何正确使用volatile

单一赋值，但是不包含复合运算
状态标志，跨线程判断业务是否结束
开销较低的读写锁策略
DCL双端锁的发布

小总结

volatile可见性、禁重排、没有原子性。
内存屏障︰是一种屏障指令，它使得CPU或编译器对屏障指令的前和后所发出的内存操作执行一个排序的约束，也叫内存栅栏或栅栏指令。
volatile写之前的操作，都禁止重排序到volatile之后。
volatile读之后的操作，都禁止重排序到volatile之前。
volatile写之后volatile读，禁止重排序。