JUC学习之共享模型之内存
Posted 大忽悠爱忽悠
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JUC学习之共享模型之内存相关的知识，希望对你有一定的参考价值。
- 前言导读
Monitor 主要关注的是访问共享变量时，保证临界区代码的原子性
这一章我们进一步深入学习共享变量在多线程间的【可见性】问题与多条指令执行时的【有序性】问题
Java 内存模型
JMM 即 Java Memory Model，它定义了主存、工作内存抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、
CPU 指令优化等。
JMM 体现在以下几个方面
- 原子性 - 保证指令不会受到线程上下文切换的影响
- 可见性 - 保证指令不会受 cpu 缓存的影响
- 有序性 - 保证指令不会受 cpu 指令并行优化的影响
可见性
退不出的循环
先来看一个现象，main 线程对 run 变量的修改对于 t 线程不可见，导致了 t 线程无法停止：
package share;
import static java.lang.Thread.sleep;
public class Main
static boolean run = true;
public static void main(String[] args) throws InterruptedException
Thread t = new Thread(()->
while(run)
// ....
);
t.start();
sleep(1);
run = false; // 线程t不会如预想的停下来
为什么呢？分析一下：
- 初始状态， t 线程刚开始从主内存读取了 run 的值到工作内存。
- 因为 t 线程要频繁从主内存中读取 run 的值，JIT 编译器会将 run 的值缓存至自己工作内存中的高速缓存中，
减少对主存中 run 的访问，提高效率
- 1 秒之后，main 线程修改了 run 的值，并同步至主存，而 t 是从自己工作内存中的高速缓存中读取这个变量
的值，结果永远是旧值
解决方法
volatile（易变关键字）
它可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取
它的值，线程操作 volatile 变量都是直接操作主存
两阶段终止模式
interrupt实现
复习interrupt实现两阶段终止模式: 正常线程被打断是设置打断标记为true,阻塞线程被打断会抛出异常，并清除打断标记
package share;
/**
*interrput实现两阶段终止模式
*/
public class Main
public static void main(String[] args)
Thread thread=new Thread(()->
while(true)
//获取当前线程
Thread currentThread = Thread.currentThread();
//打断标记是否为true
if(currentThread.isInterrupted())
System.out.println("呜呜呜，被打了");
break;
System.out.println("准备入睡");
try
Thread.sleep(3*1000);
catch (InterruptedException e)
System.out.println("重新设置打断标记");
//重新设置打断标记为true
currentThread.interrupt();
,"大忽悠一号");
thread.start();
//主线程打断
try
Thread.sleep(2*1000);
catch (InterruptedException e)
e.printStackTrace();
System.out.println("主线程执行打断操作");
thread.interrupt();
volatile实现
package share;
/**
*停止标记用 volatile 是为了保证该变量在多个线程之间的可见性
* 我们的例子中，即主线程把它修改为 true 对 t1 线程可见
*/
public class Main
private volatile static boolean stop=false;
public static void main(String[] args)
Thread thread=new Thread(()->
while(true)
//获取当前线程
Thread currentThread = Thread.currentThread();
//打断标记是否为true
if(stop)
System.out.println("呜呜呜，被打了");
break;
System.out.println("准备入睡");
try
Thread.sleep(3*1000);
catch (InterruptedException e)
,"大忽悠一号");
thread.start();
//主线程打断
try
Thread.sleep(1000);
catch (InterruptedException e)
e.printStackTrace();
System.out.println("主线程执行打断操作");
stop=true;
thread.interrupt();
同步模式之 Balking
定义
Balking （犹豫）模式用在一个线程发现另一个线程或本线程已经做了某一件相同的事，那么本线程就无需再做
了，直接结束返回
实现
public class MonitorService
// 用来表示是否已经有线程已经在执行启动了
private volatile boolean starting;
public void start()
log.info("尝试启动监控线程...");
synchronized (this)
if (starting)
return;
starting = true;
// 真正启动监控线程...
当前端页面多次点击按钮调用 start 时
输出
[http-nio-8080-exec-1] cn.itcast.monitor.service.MonitorService - 该监控线程已启动?(false)
[http-nio-8080-exec-1] cn.itcast.monitor.service.MonitorService - 监控线程已启动...
[http-nio-8080-exec-2] cn.itcast.monitor.service.MonitorService - 该监控线程已启动?(true)
[http-nio-8080-exec-3] cn.itcast.monitor.service.MonitorService - 该监控线程已启动?(true)
[http-nio-8080-exec-4] cn.itcast.monitor.service.MonitorService - 该监控线程已启动?(true)
这里synchronized 锁是防止多线并发执行，导致指令交错发生，而volatile是确保变量对于多个线程的可见性，而不是用来处理并发交错问题的
它还经常用来实现线程安全的单例
public final class Singleton
private Singleton()
private static Singleton INSTANCE = null;
public static synchronized Singleton getInstance()
if (INSTANCE != null)
return INSTANCE;
INSTANCE = new Singleton();
return INSTANCE;
对比一下保护性暂停模式：保护性暂停模式用在一个线程等待另一个线程的执行结果，当条件不满足时线程等待。
指令重排
有序性
JVM 会在不影响正确性的前提下，可以调整语句的执行顺序，思考下面一段代码
static int i;
static int j;
// 在某个线程内执行如下赋值操作
i = ...;
j = ...;
可以看到，至于是先执行 i 还是 先执行 j ，对最终的结果不会产生影响。所以，上面代码真正执行时，既可以是
i = ...;
j = ...;
也可以是
j = ...;
i = ...;
这种特性称之为『指令重排』，多线程下『指令重排』会影响正确性。为什么要有重排指令这项优化呢？从 CPU
执行指令的原理来理解一下吧
指令级并行原理
名词
Clock Cycle Time
- 主频的概念大家接触的比较多，而 CPU 的
Clock Cycle Time（时钟周期时间），等于主频的倒数，意思是CPU 能够识别的最小时间单位，比如说 4G 主频的 CPU 的 Clock Cycle Time 就是 0.25 ns，作为对比，我们墙上挂钟的Cycle Time 是 1s - 例如，运行一条加法指令一般需要一个时钟周期时间
CPI
- 有的指令需要更多的时钟周期时间，所以引出了 CPI （Cycles Per Instruction）指令平均时钟周期数
IPC
- IPC（Instruction Per Clock Cycle） 即 CPI 的倒数，表示每个时钟周期能够运行的指令数 CPU
执行时间
程序的 CPU 执行时间，即我们前面提到的 user + system 时间，可以用下面的公式来表示
程序 CPU 执行时间 = 指令数 * CPI * Clock Cycle Time
鱼罐头的故事
加工一条鱼需要 50 分钟，只能一条鱼、一条鱼顺序加工…
可以将每个鱼罐头的加工流程细分为 5 个步骤：
- 去鳞清洗 10分钟
- 蒸煮沥水 10分钟
- 加注汤料 10分钟
- 杀菌出锅 10分钟
- 真空封罐 10分钟
即使只有一个工人，最理想的情况是：他能够在 10 分钟内同时做好这 5 件事，因为对第一条鱼的真空装罐，不会
影响对第二条鱼的杀菌出锅…
指令重排序优化
事实上，现代处理器会设计为一个时钟周期完成一条执行时间最长的 CPU 指令。为什么这么做呢？可以想到指令
还可以再划分成一个个更小的阶段，例如，每条指令都可以分为： 取指令 - 指令译码 - 执行指令 - 内存访问 - 数据写回 这 5 个阶段
术语参考：
- instruction fetch (IF)
- instruction decode (ID)
- execute (EX)
- memory access (MEM)
- register write back (WB)
在不改变程序结果的前提下，这些指令的各个阶段可以通过重排序和组合来实现指令级并行，这一技术在 80’s 中
叶到 90’s 中叶占据了计算架构的重要地位。
提示：
分阶段，分工是提升效率的关键！
指令重排的前提是，重排指令不能影响结果，例如
// 可以重排的例子
int a = 10; // 指令1
int b = 20; // 指令2
System.out.println( a + b );
// 不能重排的例子
int a = 10; // 指令1
int b = a - 5; // 指令2
支持流水线的处理器
现代 CPU 支持多级指令流水线，例如支持同时执行 取指令 - 指令译码 - 执行指令 - 内存访问 - 数据写回 的处理
器，就可以称之为五级指令流水线。这时 CPU 可以在一个时钟周期内，同时运行五条指令的不同阶段（相当于一
条执行时间最长的复杂指令），IPC = 1，本质上，流水线技术并不能缩短单条指令的执行时间，但它变相地提高了指令地吞吐率。
提示：
奔腾四（Pentium 4）支持高达 35 级流水线，但由于功耗太高被废弃
SuperScalar 处理器
大多数处理器包含多个执行单元，并不是所有计算功能都集中在一起，可以再细分为整数运算单元、浮点数运算单
元等，这样可以把多条指令也可以做到并行获取、译码等，CPU 可以在一个时钟周期内，执行多于一条指令，即IPC>1
CPU 缓存结构原理
1. CPU 缓存结构
查看 cpu 缓存
⚡ root@yihang01 ~ lscpu
Architecture: x86_64
CPU op-mode(s): 32-bit, 64-bit
Byte Order: Little Endian
CPU(s): 1
On-line CPU(s) list: 0
Thread(s) per core: 1
Core(s) per socket: 1
Socket(s): 1
NUMA node(s): 1
Vendor ID: GenuineIntel
CPU family: 6
Model: 142
Model name: Intel(R) Core(TM) i7-8565U CPU @ 1.80GHz
Stepping: 11
CPU MHz: 1992.002
BogoMIPS: 3984.00
Hypervisor vendor: VMware
Virtualization type: full
L1d cache: 32K
L1i cache: 32K
L2 cache: 256K
L3 cache: 8192K
NUMA node0 CPU(s): 0
速度比较
查看 cpu 缓存行
⚡ root@yihang01 ~ cat /sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size
64
cpu 拿到的内存地址格式是这样的
[高位组标记][低位索引][偏移量]
2.CPU 缓存读
读取数据流程如下
- 根据低位，计算在缓存中的索引
- 判断是否有效
0 去内存读取新数据更新缓存行
1 再对比高位组标记是否一致
- 一致，根据偏移量返回缓存数据
- 不一致，去内存读取新数据更新缓存行
3. CPU 缓存一致性
MESI 协议
- E、S、M 状态的缓存行都可以满足 CPU 的读请求
- E 状态的缓存行，有写请求，会将状态改为 M，这时并不触发向主存的写
- E 状态的缓存行，必须监听该缓存行的读操作，如果有，要变为 S 状态
-
M 状态的缓存行，必须监听该缓存行的读操作，如果有，先将其它缓存（S 状态）中该缓存行变成 I 状态（即 6的流程），写入主存，自己变为 S 状态
-
S 状态的缓存行，有写请求，走 4. 的流程
-
S 状态的缓存行，必须监听该缓存行的失效操作，如果有，自己变为 I 状态
-
I 状态的缓存行，有读请求，必须从主存读取
诡异的结果
boolean ready = false;
int num = 0;
// 线程1 执行此方法
public void actor1(I_Result r)
if(ready)
r.r1 = num + num;
else
r.r1 = 1;
// 线程2 执行此方法
public void actor2(I_Result r)
num = 2;
ready = true;
I_Result 是一个对象，有一个属性 r1 用来保存结果，问，可能的结果有几种？
有同学这么分析
- 情况1：线程1 先执行，这时 ready = false，所以进入 else 分支结果为 1
- 情况2：线程2 先执行 num = 2，但没来得及执行 ready = true，线程1 执行，还是进入 else 分支，结果为1
- 情况3：线程2 执行到 ready = true，线程1 执行，这回进入 if 分支，结果为 4（因为 num 已经执行过了）
但我告诉你，结果还有可能是 0 😁😁😁，信不信吧！
这种情况下是：线程2 执行 ready = true，切换到线程1，进入 if 分支，相加为 0，再切回线程2 执行 num = 2
相信很多人已经晕了 😵😵😵
这种现象叫做指令重排，是 JIT 编译器在运行时的一些优化，这个现象需要通过大量测试才能复现：
借助 java 并发压测工具 jcstress
mvn archetype:generate -DinteractiveMode=false -DarchetypeGroupId=org.openjdk.jcstress -
DarchetypeArtifactId=jcstress-java-test-archetype -DarchetypeVersion=0.5 -DgroupId=cn.dhy-
DartifactId=ordering -Dversion=1.0
创建 maven 项目，提供如下测试类
@JCStressTest
@Outcome(id = "1", "4", expect = Expect.ACCEPTABLE, desc = "ok")
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "!!!!")
@State
public class ConcurrencyTest
int num = 0;
boolean ready = false;
@Actor
public void actor1(I_Result r)
if(ready)
r.r1 = num + num;
else
r.r1 = 1;
@Actor
public void actor2(I_Result r)
num = 2;
ready = true;
执行
mvn clean install
java -jar target/jcstress.jar
会输出我们感兴趣的结果，摘录其中一次结果：
*** INTERESTING tests
Some interesting behaviors observed. This is for the plain curiosity.
2 matching test results.
[OK] test.ConcurrencyTest
(JVM args: [-XX:-TieredCompilation])
Observed state Occurrences Expectation Interpretation
0 1,729 ACCEPTABLE_INTERESTING !!!!
1 42,617,915 ACCEPTABLE ok
4 5,146,627 ACCEPTABLE ok
[OK] test.ConcurrencyTest
(JVM args: [])
Observed state Occurrences Expectation Interpretation
0 1JUC学习之共享模型之工具上之线程池浅学
JUC并发编程 共享模型之内存 -- Java 内存模型 & 原子性 & 可见性(可见性问题及解决 & 可见性 VS 原子性 & volatile（易变关键字）)(代码