volatial探讨(二)-内存层探讨

最新推荐文章于 2023-07-26 23:25:09 发布
最新推荐文章于 2023-07-26 23:25:09 发布
阅读量258 收藏 1
点赞数
分类专栏： volatile cpu底层实现 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43946149/article/details/113105505
版权

1.1 内存屏障的延申

上章我们讲到了volatile之所以会阻止重排序的发生是因为。使用了两个写内存屏障。关于内存屏障可以查看:
volatial探讨(一)-重排序和内存屏障

内存屏障伪代码说明
LoadLoad BarrierLoad; barrier; load在A指令执行load的时候，B指令的load不能插队
StoreStore Barrierstore ;barrier; store在A指令执行写的时候，B指令的写操作不能插队。刷新缓存
LoadStore Barrierload; barrier;store在A指令执行读的时候，B指令的写不能插队
StoreLoad Barrierstore:load;barrier在A指令执行写的时候，B指令的读不能插队。刷新缓存

volatitle写操作加的内存屏障

------store-store-barrier--------
volatile-写
------store-Load-barrier--------

volatitle读操作加的内存屏障

----load-load-barrier----
volatitle-读
----load-store-barrier—

我们能看到两个写内存屏障会发起一个刷新缓存的操作。
那么这个缓存刷新的过程是什么呢？

1.1.2 barrier发起的刷新缓存的过程

想要详细的理解刷新的过程，首先我们要先了解一下cpu的一些组成

我们首先要理解一下cpu的缓存架构

在这里插入图片描述

L1i:cpu的指令缓存
L1D:cpu的数据缓存
L2Cache:cpu的级缓存
L3-cache:多个cpu共享的3级缓存
Bus:cpu总线，用来控制与cpu外部硬件进行沟通，例如内存等部位

每层缓存都要从上层缓存区数据。

L1和L2的缓存都在cpu内部，所以就会引来一个新的问题，即缓存一致性的问题，例如cpu1对L2的缓存做了修改，这个时候对cpu2来说是不可见的。在某些情况下这中结果会是灾难性的。

那么我们来看一个由于缓存不同步引起的经典的案例

1.1.1

先看一个样例，在volatile修饰下不同线程的的表现形式

示例-1
package com.gxw.first.code.volite;

public class Visibility {
    public boolean flag = true;       // 注释1-1    
    public volatile boolean flag = true; //注释1-2  
    public static void main(String[] args) throws InterruptedException {
        Visibility visibility = new Visibility();
        //t1负责执行死循环
        Thread t1 = new Thread(() ->
            {
                System.out.println("execute begin!");
                //死循环执行器
                visibility.execute();
                System.out.println("execute end");
            }
        );
        //t2负责结束t1的死循环
        Thread t2 = new Thread(() -> {
            visibility.updateFlag();
            System.out.println("update flag false!");
        }
        );
        t1.start();
        Thread.sleep(5000);
        t2.start();
        t1.join();t2.join();
    }


    public void execute() {
        int i=1 ,j=0;
        while (flag) {
           i++;
           /*  注释1-3
           if (flag&&((i%100)==0)){
               j++;
               System.out.print(".");  
               if (j%150==0){
                   System.out.println("");
               }
           }
           */
        }
    }

    public void updateFlag() {
        this.flag = false;
    }

}

解析 ：
1、在flag没有被volatile修饰的时候 打开注释1-1
执行结果

>execute begin!
>update flag false!
**程序未退出**

2、在有volatile修饰的时候 打开注释1-2
执行结果

>execute begin!
>update flag false!
>execute end
>
>Process finished with exit code 0
>**程序退出**

3、在无volatile修饰的时候，执行方法中有System.out.println() 打开注释1-3，1-1
执行结果

>execute begin!
>......................................................................................................................................................
>......................................................................................................................................................
>.....................................................................................................................
>update flag false!
>execute end
>
>Process finished with exit code 0
>**程序退出**

可以看到变量在没有volital修饰的情况下，一个线程对于flag的修改对于另一个线程不可见。

原理：在使用了StoreStoreBarrier和StoreLoadBarrier这两种内存屏障的的时候，会强制cpu刷新cache区中的变量，重新从内存中读取。
根据jvm规范：
1、lock 解锁时会触发刷新
2、volatile 写操作时
3、final 写操作的时候

在操作系统的定义中，一个cpu核心可以并发的来执行多个线程，但是不能并行处理。
cpu在每个线程的时间片执行完毕后，会保存线程的上下文进行切换。所以对线程来
说即使两条线程是同一个CPU来执行，对于线程来说是无感知的（这个说法并不完全
精确，但是可以这样理解，有兴趣的可以详细的查看计算机组成原理和操作系统的
相关教材），所以下文举例中所有的CPU都是逻辑意义上线程感知到的CPU。

我们来看一下cpu交互的过程
在这里插入图片描述

可以看到，cpu2在执行另一条线程的时候，已经把从内存中读取的变量改为了flase值，而这个时候他的修改对cpu1并不可见，所以cpu-1仍在继续执行循环逻辑

这个时候细心的小朋友已经发现，开头的表格中说，内存屏障可以用于刷新缓存，那么是cpu是怎么通过内存屏障刷新缓存的呢？

我们来看一种解决方案

1.1.3 缓存一致性协议

在开始读取的时候因为值没有被修改，所有的缓存都是一致的

图：A-1
在这里插入图片描述

当其中一个线程修改后

这个时候cpu-1和cpu-2中的缓存由于没有感知到变化所以依旧会继续执

图：A-2
在这里插入图片描述

cpu会向总线发出一个Invalid指令，此时CPU-1和CPU-2就感知到flag这个变量发生了改变

图A-3
在这里插入图片描述

这个时候，CPU-1和CPU-2收到Invalid指令后，会反馈一个ack给CPU-3。当CPU-3收到所有的ACK后，CPU-1和CPU-2就会重新同步数据。

图A-4
在这里插入图片描述

最终3个cpu的缓存通过S指令的重新读取缓存后，就变为一致的

图A-5
在这里插入图片描述

以上的过程叫做缓存同步，或者叫做缓存一致过程

当然真正的缓存一致定制了一个比较复杂的协议，叫做缓存一致性协议

这个协议制定了4种缓存状态

M状态（修改）E状态（独享）S状态(共享)I状态（无效）

M状态:在图A-2中，CPU-3在flag值发生修改的时候会将缓存修改为M状态

E状态:当图A-1中CPU-2未加载Flag值到缓存中的时候，缓存状态未E状态

S状态：在图A-1中两个cpu同时使用了flag的缓存，缓存状态被称为S状态

I状态：在图A-3中flag的值被修改的情况下，CPU-3会把自己的缓存修改为I状态

以上步骤就是完整的缓存同步步骤，是不是还有些疑惑？同步缓存要通知到每个CPU，等待ACK的时间这么久？CPU-3在等ACK的时候岂不是浪费了很多时间？

还是那句老话，解决问题的时候总是会引发新的问题。
我们来看看缓存同步的过程是如何优化的

1.1.3 优化后的缓存一致性协议

1.1.3.1Store Buffer的引入

cpu发出Invalid指令后要等待各个CPU发出的ACK回执时间较长，浪费了CPU的资源。所以，引入了Store Buffer（写入缓存） 使CPU进行异步写操作。

在这里插入图片描述

     StoreBuffer是一个环形（Ring）的buffer，每个cpu持有StoreBuffer的一个节点，
 当一个CPU要进行修改操作的时候，会将修改的结果写入StoreBuffer中同时
 对其他cpu发出Invalid指令，其他CPU在进行ack回复后，会先尝试从StoreB
 uffer中取出修改后的值。

1.2.1 总线和位宽

再说一说CPU内部的缓存和总线的位宽
cpu总线分为三个部分

1、地址总线
2、数据总线
3、控制总线

在这里插入图片描述

地址总线：CPU用来寻找内存的地址
地址总线的位宽决定了，cpu寻找内存地址的速度

在这里插入图片描述

数据总线：数据总线的宽度决定了CPU与其他器件进行数据传送时，一次可以传送多少数据。
数据总线：一个数据总线只能传输一个二进制位

在这里插入图片描述
数据总线

可以看到控制总线负责发出读写信号，而后地址总线负责寻址，数据总线负责发出数据流进行写入。相互之间协调进行内存数据的读写。

1.1.4 位宽与volatile之间的关联

根据前面的缓存一致性协议我们可以了解到，在发出Invalid指令后会导致
其他cpu将自己缓存内的值置为失效。那么问题来了，需要失效的缓存有哪些？
最好的情况 flag=true，只使true这一个变量失效，但是不同数据类型的长度
是不同的，cpu无法感知自己运算的每个数据类型。那么问题来了。要失效哪些
内存效率可以达到最高呢？

从上面的cpu总线图可以知道，cpu读取数据总是按照位宽来读取的，常见的pc和服务器，位宽都在32或者64位。cpu读取数据后会放入L2和L3的缓存中L2和L3缓存通常是64字节一行，也就是在64位宽的情况下，L2或者L3缓存的一行数据，cpu要读取8次。在多种语言当中，很少有单个类型的数据长度超过64字节。所以大部分情况L2和L3的一行缓存当中可以存放2个以上的数据。

下面我们来看一段代码：
是java-juc包的作者，著名的并发编程大师Doug lea在JDK7的并发包总新增的LinkedTransferQueue中使用volatile补全位缓存行来进行性能优化的代码

在这里插入图片描述

PaddedAtomicReference这个类只做了一件事，就是定义了p0-pe 这15个引用类型的变量，java中引用类型变量长度位4个字节，15个变量占用60字节。在加上父类的value变量，这个队列中的node节点共占用64字节。

如果队列的头节点和尾节点都不足64字节的话，处理器会将它们都读到同一个高速缓存行中，在多处理器下每个处理器都会缓存同样的头、尾节点，当一个处理器试图修改头节点时，会将整个缓存行锁定，那么在缓存一致性机制的作用下，会导致其他处理器不能访问自己高速缓存中的尾节点，而队列的入队和出队操作则需要不停修改头节点和尾节点，所以在多处理器的情况下将会严重影响到队列的入队和出队效率。Doug lea使用追加到64字节的方式来填满高速缓冲区的缓存行，避免头节点和尾节点加载到同一个缓存行，使头、尾节点在修改时不会互相锁定。

看到这里是不是惊叹与Doug lea的操作方法。不亏为真正的大师。

介绍到这里关于volatile的底层机制和常见的使用情况基本可以做个总结

1、volatile可以通过内存屏障出发缓存一致性协议来做到不同线程(cpu)的可见性
2、volatile可以解决重排序问题，进行一些简单的并发控制
3、在使用volatile清楚明白缓存行宽度且写入频繁的情况下尽可能的要使用缓存行补齐

这章我们基本介绍到这里，下章我们探讨一下单例中的volatile使用，并引发锁机制的探讨

郭希文
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CPU的缓存一致性协议与Volatile
dw147258dw的专栏
01-04 639
我们都知道CPU有三级缓存，L1，L2，为核心独享，L3为CPU共享，而当前主流的CPU还都支持Store Buffer 和invalid queue，在这种情况下MESI是无法生效的，而在一些指令重排的情况下，核心读到的值可能不是最新的，这时就需要通过指令重排来进行同步，指令重排不止具备禁止重排序的特性，还具备同步刷新的特性 volatile是JVM的内存语义，这里借用知乎中的一个回答： volatile是java语言层面给出的保证，MSEI协议是多核cpu保证cache一致性的一种方法，中间隔的还很
CPU有缓存一致性协议(MESI)，为何还需要volatile
org_hjh的博客
11-11 1784
点赞再看，养成习惯，公众号搜一搜【一角钱技术】关注更多原创技术文章。 本文 GitHub org_hejianhui/JavaStudy 已收录，有我的系列文章。 前言 并发编程从操作系统底层工作的整体认识开始 深入理解Java内存模型(JMM)及volatile关键字 前面我们从操作系统底层了解了现代计算机结构模型中的CPU指令结构、CPU缓存结构、CPU运行调度以及操作系统内存管理，并且学习了Java内存模型(JMM)和 volatile 关键字的一些特性。本篇来深入理解CPU缓存一致性协议(..
CPU有缓存一致性协议（MESI），为什么JMM还需要volatile关键字？
分享Java技术知识，共同成长进步！
10-12 1723
这是一个非常好的问题，相信本文能把这个问题讲得清清楚楚 上周我在查阅资料时无意中搜到一篇解释 volatile 用法的博文，这篇博文排得很靠前，不过很遗憾，虽然结论是对的，但分析过程完全错误，而且我发现网上很多文章都用这个例子来解释 volatile 的用法，但 95% 以上分析过程也是错误的，所以决定写篇博文澄清一下 到底怎么回事呢，我们一起来看看，首先来看下下面这段代码有什么问题 public class Demo { private static boolean running = tr
为什么有MESI了还要volatile？你真的了解volatile吗
womeiyouzaihuashui的博客
08-20 4284
目录前言二级目录三级目录 前言 我们先假设这样一个场景： 面试官：“小伙子，看你简历写了精通多线程，能说下什么是JMM吗？” 你：“JMM就是Java内存模型，这个呢要先从CPU缓存架构说起巴拉巴拉……所以JMM就是为了屏蔽操作系统这些底层细节，为了能够做到一次编译到处运行而实现的一套抽象机制。” 面试官：“不错，那volatile知道吗？说下它的原理呗。” 你：“前面说了CPU缓存，在多核的情况下为了保证缓存一致性，CPU引入了MESI缓存一致性协议，” 二级目录 三级目录 ...
为什么有了MESI还需要volatile关键字
liangsheng_g的专栏
07-08 919
MESI的概念此处不再累赘，有兴趣的可以搜索 store buffer 引入store buffer是为了将同步改为异步 引入store forwarding技术是为了让CPU可以直接从store buffer里加载数据 但是因此可能会发生乱序情况，譬如a在store buffer里，b在cache里，但是赋值操作虽然先设置了a，后设置了b，但是实际上却可能是b先被刷新到cache里，因为store buffer里的a在等待其他cpu返回invalid ack 引入写屏障技术，添加smp_w
既然CPU有缓存一致性协议（MESI），为什么JMM还需要volatile关键字？
来啊 快活啊
08-22 484
既然CPU有缓存一致性协议（MESI），为什么JMM还需要volatile关键字？ MESI缓存一致性协议在哪里以及如何实现？ Intel® 64 and IA-32 Architectures Developer’s Manual: Vol. 3A
JMM一致性协议
weixin_34049948的博客
04-14 227
JMM中一些普通变量的操作指令 A、Load操作发生在read之后（两个之间可以有其他的指令）B、普通变量的修改未必会立即发生Store操作，但发生Store操作，就会发生write操作 最细的粒度支持，也就是对Load、Store的各种顺序控制，load、store两两组合为4中情况，LoadLoad、StoreStore、LoadS...
JMM Volatile 缓存一致性协议
最新发布
kankan_s的专栏
07-26 118
对于更复杂的多线程应用程序，通常需要使用更高级的同步机制，如锁和条件变量，以保证线程安全和正确性。在 Java 中，JMM（Java Memory Model）是一种规范，用于定义多线程程序中共享变量的可见性和顺序性。缓存一致性是指多核处理器中，每个核心都有自己的缓存，并且当多个核心访问相同的共享变量时，保证这些缓存中的变量值保持一致。是 JMM 提供的关键字之一，用于确保线程之间的可见性和禁止指令重排序，以实现缓存一致性协议。的值时，会从主内存中读取最新的值。，这样在多线程环境下，调用。
「 操作系统 」CPU缓存一致性协议MESI详解
frozenpenguin的博客
05-15 4090
说回CPU缓存，缓存行（cache line）是CPU缓存的基本单位，缓存行通常是 32/64 字节,前面说了局部性原理。当我们访问一个数据时，获取一个值后，其相邻的值也被缓存到就近的缓存行中。比如访问一个long类型数组，当数组中的一个值被加载到缓存中，它会额外加载另外7个，以致你能非常快地遍历这个数组。因此可以非常快速的遍历在连续的内存块中分配的任意数据结构。但是没有任何是完美的存在，比如：当有多个线程操作不同的成员变量，但正好这多个变量处于相同的缓存行。
JMM内存模型 Volatile 缓存一致性协议
weixin_43838446的博客
04-01 493
1. 计算机多核并发缓存架构 在多处理器系统中，每个处理器都有自己的高速缓存，而它们又共享同一主内存（MainMemory）： 2. JMM内存模型 JMM数据原子操作： read (读取) :从主内存读取数据 load (载入) :将主内存读取到的数据写入工作内存 use(使用) :从工作内存读取数据来计算 assign (赋值) :将计算好的值重新赋值到工作内存中 store (存储) :...
浅谈缓存一致性原则和Java内存模型（JMM）
sdr_zd的博客
08-01 6896
Java内存模型（JMM）是一个概念模型，底层是计算机的寄存器、缓存内存、主内存和CPU等。 多处理器环境下，共享数据的交互硬件设备之间的关系： JMM: 从以上两张图中，谈一谈以下几个概念： 1.缓存一致性协议（MESI）： 由于每个处理器都含有私有的高速缓存，在对缓存中数据进行更新后，其他处理器中所含有的该共享变量的缓存如果被处理器进行读操作，就会出现错误。有些计算机采用LO...
JAVA系列：JVM内存模型之缓存一致性协议
NIO4444
09-09 1439
目录 线程之间的通信 线程之间的同步 主内存和工作内存 缓存一致性协议 总线锁 缓存锁 缓存一致性协议 CPU的优化执行 并发编程的问题 硬件架构 三大特征 原子性（Atomicity） 可见性 有序性 线程之间的通信 线程的通信是指线程之间以何种机制来交换信息。 在命令式编程中，线程之间的通信机制有两种：共享内存和消息传递。 在共享内存的并发模型里，线程之间共享程序的公共状态，线程之间通过写-读内存中的公共状态来隐式进行通信，典型的共享内存通信方式就是通过共享对.
缓存一致性协议和volatile
Backee的博客
04-18 1045
在阅读LongAdder源码的过程中，碰到了@sun.misc.Contended的使用，在百度了一下后了解到该注解是为了解决伪共享问题。 什么是伪共享？ 要想彻底了解伪共享，首先要对缓存行（也可称为缓存段），和缓存一致性协议有所了解。个人在网上找了许多资料认为：缓存一致性（Cache Coherency）入门，这篇简绍的比较好，建议大家阅读一下。 以及了解缓存一致性协议（MESI）的具体流程这里我推荐：缓存一致性协议的工作方式（但是里面在脏段被修改后，其它CPU依然可以...
缓存一致性以及JMM模型理解
cdtu007的博客
12-09 649
计算机多CPU模型： 1.多CPU： 一个现代计算机通常由两个或者多个CPU，如果要运行多个程序（进程）的话，假如只有 一个CPU的话，就意味着要经常进行进程上下文切换，因为单CPU即便是多核的，也只是多个 处理器核心，其他设备都是共用的，所以 多个进程就必然要经常进行进程上下文切换，这个代 价是很高的。 2.cpu多核： 一个现代CPU除了处理器核心之外还包括寄存器、L1L2L3缓存这些存储设备、浮点运算 单元、整数运算单元等一些辅助运算设备以及内部总线等。...
Java架构师学习之路之并发编程一： 缓存一致性协议和JMM
qq_44988694的博客
04-08 1144
Java架构师学习之路之并发编程一： 缓存一致性协议和JMM1. 现代计算机结构2. CPU多级缓存架构3. 上述架构在多线程环境下的问题1). 缓存一致性问题2). 指令重排问题4. 线程1). 什么是线程2). 线程的分类3). Java线程的生命周期：5. 并发并发的优缺点6.JMM模型1). 什么是JMM2). JMM模型下线程和内存的交互3). JMM同步的八种操作4). 为什么要设计JMM 1. 现代计算机结构 现代计算机结构如上图，其中我们需要了解的部分是： CPU有高速缓存——CPU C
CPU缓存一致性协议与java中的volatile关键字
weixin_30374009的博客
09-06 247
有关缓存一致性协议MESI自行百度。 提出问题：volatile在缓存一致性协议上又做了哪些事情？为啥它不保证原子性？ 在缓存一致性协议下，CPU为了执行效率使用了写（存储）缓存和失效队列从而导致对用户来说指令的乱序执行 而volatile加入了内存屏障指令，每次对共享内存的写都会立即刷新存储缓存到主内存中，而每次对共享内存的读 都会先处理失效队列，从主内存中读取最新的值，所以保证了内存的...
volatile关键字详解(从缓存一致性谈起)
SummerMangoZz的博客
07-14 4582
在讲解volatile关键字之前，我们先来看看操作系统中缓存一致性的概念。 众所周知，cpu的运行速度是远高于主存的读写速度的，在运行过程中，为了交换数据，cpu必须频繁的进行数据的读写操作，主存读写速度慢造成了cpu运行的吞吐量减少。为了解决这一问题，现在的机器都会在添加一层高速缓存(其实不止一层，有多层).以后每次cpu进行读写操作时，都直接和高速缓存交互，之后在讲高速缓存中的数据回刷到主存
JMM-硬件层数据一致性
weixin_47789590的博客
11-21 174
JMM硬件层数据一致性
JAVA并发-从缓存一致性说volatile 讲的很好
在路上2017的专栏
10-20 272
撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值