高并发编程-通过volatile重新认识CPU缓存 和 Java内存模型（JMM）

文章目录

概述

volatile定义

CPU缓存

相关CPU术语

CPU缓存一致性协议MESI

带有高速缓存的CPU执行计算的流程

CPU 多级的缓存结构

Java 内存模型 （JMM）

线程通信的两种方式

哪些变量可以共享

JMM概述

Java内存模型的抽象结构示意图

volatile 小demo

总结：volatile的两条实现原则

概述

在多线程并发编程中synchronized和volatile都扮演着重要的角色。

volatile是轻量级的 synchronized，它在高并发中保证了共享变量的“可见性”。

那什么是可见性呢？

可见性 我们可以理解为：当一个线修改一个共享变量时，另外一个线程能读到这个修改的值。

如果volatile变量修饰符使用恰的话，它比synchronized的使用和执行成本更低，因为

volatile不会引起线程上下文的切换和调度

volatile定义

Java规范第3版中对volatile的定义如下：

Java允许线程访问共享变量，为了确保共享变量能被准确和一致地更新，线程应该确保通过排他锁单独获得这个变量。

Java提供了volatile关键字，在某些场景下volatile比锁synchronized要更加方便。

如果一个字段被声明成volatile，Java线程内存模型(JMM)确保所有线程看到这个变量的值是一致的 .

CPU缓存

相关CPU术语

了解volatile实现原理之前，先了解下与其实现原理相关的CPU术语

CPU缓存一致性协议MESI

CPU缓存一致性协议MESI 请参考： CPU缓存一致性协议MESI

【M 修改 (Modified) E 独享、互斥 (Exclusive) S 共享 (Shared) I 无效 (Invalid) 】

CPU的发展速度非常快，而内存和硬盘的发展速度远远不及CPU。这就造成了高性能能的内存和硬盘价格及其昂贵。然而CPU的高度运算需要高速的数据。为了解决这个问题，CPU厂商在CPU中内置了少量的高速缓存以解决I\O速度和CPU运算速度之间的不匹配问题

为了提高效率，CPU不直接和内存进行通信，而是先将系统内存的数据读取到内部缓存（L1、L2或其他）后再进行操作。

但是有个问题： 当操作完成后，被修改的数据何时回写到主内存呢？

假设某个共享变量声明了volatile关键字进行写操作 ，JVM就会向处理器发送一条Lock前缀指令，将这个变量所在缓存行的数据写回到系统内存。

OK，就算写回到内存，如果其他处理器缓存的值还是旧的，再执行计算操作就会有问题。

所以，在多处理器下，为了保证各个处理器的缓存是一致的，就要实现缓存一致性协议 ，每个处理器通过嗅探在总线（BUS）上传播的数据来检查自己缓存的值是不是过期了

当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，

当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存

带有高速缓存的CPU执行计算的流程

程序以及数据被加载到主内存

指令和数据被加载到CPU的高速缓存

CPU执行指令，把结果写到高速缓存

高速缓存中的数据写回主内存

CPU 多级的缓存结构

由于CPU的运算速度超越了1级缓存的数据I\O能力，CPU厂商又引入了多级的缓存结构。

L1/L2/L3 Cache速度差别

L1 cache: 3 cycles

L2 cache: 11 cycles

L3 cache: 25 cycles

Main Memory: 100 cycles

通常L1 Cache离CPU核心需要数据的地方更近，而L2 Cache则处于边缓位置，访问数据时，L2 Cache需要通过更远的铜线，甚至更多的电路，从而增加了延时。

参见： 细说Cache-L1/L2/L3/TLB

Java 内存模型 （JMM）

线程通信的两种方式

我们知道 线程间的通信，主要分为两种方式

共享内存 (线程之间共享程序的公共状态，通过写-读内存中的公共状态进行隐式通信)

消息传递 (线程之间必须通过发送消息来显式进行通信)

哪些变量可以共享

Java的并发采用的是共享内存模型 ， 在Java中，所有实例域、静态域和数组元素都存储在堆内存中，堆内存在线程之间共享 ，我们使用”共享变量”这个术语代指实例域，静态域和数组元素

局部变量，方法定义参数和异常处理器参数不会在线程之间共享，它们不会有内存可见性问题，也不受内存模型的影响。

JMM概述

Java线程之间的通信由Java内存模型JMM）控制，JMM决定一个线程对共享变量的写入何时对另一个线程可见 .

JMM定义了线程和主内存之间抽象关系：线程之间的共享变量存储在主内存（Main Memory）中，每个线程都有一个私有的本地内存（Local Memory），本地内存中存储了该线程以读/写共享变量的副本。

注： 本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存、写缓冲区、寄存器以及其他的硬件和编译器化

Java内存模型的抽象结构示意图

如下：

根据上述的描述，如果线程A和线程B要通信的话，步骤如下

线程A把本地内存A中更新过的共享变量刷新到主内存中去

线程B到主内存中去读取线程A之前已更新过的共享变

线程A和线程B通信示意图如下所示

本地内存A和本地内存B由主内存中共享变量x的副本。

假设初始时，这3个内存（本地内存A、本地内存B、主内存）中的x值都为0。

线程A在执行时，把更新后的x值（假设值为1）临时存放在自己的本地内A中。

当线程A和线程B需要通信时，线程A首先会把自己本地内存中修改后的x值刷新到主内存中，此时主内存中的x值变为了1。

随后，线程B到主内存中去读取线程A更新后的x值，此时线程B的本地内存的x值也变为了1。

从整体来看，这两个步骤实质上是线程A在向线程B发送消息，而且这个

通信过程必须要经过主内存。

JMM通过控制主内存与每个线程的本地内存之间的交互，来保证内存可见性保证。

volatile 小demo

先来个例子 感受下volatile的作用

俩线程 1个读取共享变量 另外1个更新共享变量.

package com.artisan.test; /** * 俩线程 *

* 1个读取共享变量 * 1个更新共享变量 */ public class VolatileDemo { // 共享变量 private volatile static int SHARED_VALUE = 0; private final static int MAX_VALUE = 10; public static void main(String[] args) { // 定义 读取线程 new Thread(() -> { int localValue = SHARED_VALUE; // 循环， 如果localValue ！= SHARED_VALUE 输出信息 while (SHARED_VALUE < MAX_VALUE){ if (localValue != SHARED_VALUE){ System.out.printf(Thread.currentThread().getName() + ": the SHARED_VALUE value has been updated to [%d] \n" , SHARED_VALUE); localValue = SHARED_VALUE; } } }, "Reader Thread").start(); // 定义 更新线程 new Thread(() -> { int localValue = SHARED_VALUE; // 循环 如果小于最大值，则更新localValue while (SHARED_VALUE < MAX_VALUE){ System.out.printf(Thread.currentThread().getName() + ": update SHARED_VALUE to [%d] \n" , ++localValue); SHARED_VALUE = localValue; try { // 为了演示效果，休眠一下 Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } } }, "Update Thread").start(); } }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

輸出：

Update Thread: update SHARED_VALUE to [1] Reader Thread: the SHARED_VALUE value has been updated to [1] Update Thread: update SHARED_VALUE to [2] Reader Thread: the SHARED_VALUE value has been updated to [2] Update Thread: update SHARED_VALUE to [3] Reader Thread: the SHARED_VALUE value has been updated to [3] Update Thread: update SHARED_VALUE to [4] Reader Thread: the SHARED_VALUE value has been updated to [4] Update Thread: update SHARED_VALUE to [5] Reader Thread: the SHARED_VALUE value has been updated to [5] Update Thread: update SHARED_VALUE to [6] Reader Thread: the SHARED_VALUE value has been updated to [6] Update Thread: update SHARED_VALUE to [7] Reader Thread: the SHARED_VALUE value has been updated to [7] Update Thread: update SHARED_VALUE to [8] Reader Thread: the SHARED_VALUE value has been updated to [8] Update Thread: update SHARED_VALUE to [9] Reader Thread: the SHARED_VALUE value has been updated to [9] Update Thread: update SHARED_VALUE to [10] Process finished with exit code 0

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

如果 去掉volatile关键字呢 ？ 测试如下

由此可见 volatile关键字在高并发中保证了共享变量的“可见性”。

总结：volatile的两条实现原则

总结一下

Lock前缀指令会引起处理器缓存回写到内存

一个处理器的缓存回写到内存会导致其他处理器的缓存无效

Java 任务调度

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。