共享模型之内存
Posted 野生java研究僧
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了共享模型之内存相关的知识，希望对你有一定的参考价值。
共享模型之内存
4.共享模型之内存
4.1 Java 内存模型
JMM 即 Java Memory Model，它定义了主存、工作内存抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、CPU 指令优化等。
JMM 体现在以下几个方面
- 原子性 - 保证指令不会受到线程上下文切换的影响
- 可见性 - 保证指令不会受 cpu 缓存的影响
- 有序性 - 保证指令不会受 cpu 指令并行优化的影响
4.2 可见性
退不出的循环 先来看一个现象，main 线程对 run 变量的修改对于 t 线程不可见，导致了 t 线程无法停止：
// 本意：让程序在睡眠1秒后，main线程将run设置为false，让while循环停止下来
static boolean run = true;
public static void main(String[] args) throws InterruptedException
Thread t = new Thread(()->
while(run)
);
t.start();
Util.sleep(1);
run = false; // 线程t不会如预想的停下来
为什么呢？分析一下：
- 初始状态， t 线程刚开始从主内存读取了 run 的值到工作内存。
- 因为 t 线程要频繁从主内存中读取 run 的值，JIT 编译器会将 run 的值缓存至自己工作内存中的高速缓存中， 减少对主存中 run 的访问，提高效率
- 1秒之后，main 线程修改了 run 的值，并同步至主存，而 t 是从自己工作内存中的高速缓存中读取这个变量 的值，结果永远是旧值
解决方法1: volatile（易变关键字）
它可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取 它的值，线程操作 volatile 变量都是直接操作主存。
volatile static boolean run = true;
public static void main(String[] args) throws InterruptedException
Thread t = new Thread(()->
while(run)
);
t.start();
Util.sleep(1);
run = false;
解决方案2：synchronized 可以保证原子性，还能保证可见性
synchronized在修改了本地内存中的变量后，解锁前会将本地内存修改的内容刷新到主内存中，确保了共享变量的值是最新的，也就保证了可见性。
volatile static boolean run = true;
static Object lock = new Object();
public static void main(String[] args) throws InterruptedException
Thread t = new Thread(()->
while(true)
synchronized (lock)
if (!run)
break;
);
t.start();
Util.sleep(1);
synchronized (lock)
run = false;
可见性 vs 原子性
前面例子体现的实际就是可见性，它保证的是在多个线程之间，一个线程对 volatile 变量的修改对另一个线程可 见， 不能保证原子性，仅用在一个写线程，多个读线程的情况： 上例从字节码理解是这样的：
getstatic run // 线程 t 获取 run true
getstatic run // 线程 t 获取 run true
getstatic run // 线程 t 获取 run true
getstatic run // 线程 t 获取 run true
putstatic run // 线程 main 修改 run 为 false， 仅此一次
getstatic run // 线程 t 获取 run false
比较一下之前我们将线程安全时举的例子：两个线程一个 i++ 一个 i-- ，只能保证看到最新值，不能解决指令交错
// 假设i的初始值为0
getstatic i // 线程2-获取静态变量i的值 线程内i=0
getstatic i // 线程1-获取静态变量i的值 线程内i=0
iconst_1 // 线程1-准备常量1
iadd // 线程1-自增 线程内i=1
putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=1
iconst_1 // 线程2-准备常量1
isub // 线程2-自减 线程内i=-1
putstatic i // 线程2-将修改后的值存入静态变量i 静态变量i=-1
注意 synchronized 语句块既可以保证代码块的原子性，也同时保证代码块内变量的可见性。但缺点是 synchronized 是属于重量级操作，性能相对更低
如果在前面示例的死循环中加入 System.out.println() 会发现即使不加 volatile 修饰符，线程 t 也能正确看到 对 run 变量的修改了，想一想为什么？
因为 System.out.println()中的println()方法由synchronized 关键字修饰
4.3 同步模式-Balking
alking （犹豫）模式用在一个线程发现另一个线程或本线程已经做了某一件相同的事，那么本线程就无需再做 了，直接结束返回
@Slf4j
public class MyTest
public static void main(String[] args) throws InterruptedException
TwoPhaseTermination termination = new TwoPhaseTermination();
// 启动监视器 3s后关闭
termination.start();
termination.start();
Thread.sleep(4000);
log.debug("停止监控...");
termination.stop();
@Slf4j
class TwoPhaseTermination
// 监视器
private Thread monitor;
private volatile boolean stop = false;
// 用来标识是否已经有线程已经在执行启动了
private volatile boolean starting=false;
public void start()
// 进行判断避免 重复start()
synchronized (this)
if (starting)
log.debug("获取锁失败");
return;
starting = true;
monitor=new Thread(()->
while (true)
// 根据停止标记来停止监控
if (stop)
log.debug("释放资源...");
break;
try
Thread.sleep(500);
log.debug("执行监控任务...");
catch (Exception e)
e.printStackTrace();
,"monitor");
monitor.start();
public void stop()
stop=true;
monitor.interrupt();
它还经常用来实现线程安全的单例
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;
4.4有序性
JVM 会在不影响正确性的前提下，可以调整语句的执行顺序，思考下面一段代码
static int i;
static int j;
// 在某个线程内执行如下赋值操作
i = ...;
j = ...;
可以看到，至于是先执行 i 还是 先执行 j ，对最终的结果不会产生影响。所以，上面代码真正执行时，既可以是
i = ...;
j = ...;
也可以是
j = ...;
i = ...;
这种特性称之为『指令重排』，多线程下『指令重排』会影响正确性。为什么要有重排指令这项优化呢？从 CPU 执行指令的原理来理解一下吧
4.5指令级并行原理
指令重排序优化: 事实上，现代处理器会设计为一个时钟周期完成一条执行时间最长的 CPU 指令。为什么这么做呢？可以想到指令 还可以再划分成一个个更小的阶段，例如，每条指令都可以分为： 取指令 - 指令译码 - 执行指令 - 内存访问 - 数据 写回 这 5 个阶段
在不改变程序结果的前提下，这些指令的各个阶段可以通过重排序和组合来实现指令级并行，这一技术在 80年代中叶到 90年代中叶占据了计算架构的重要地位。
提示： 分阶段，分工是提升效率的关键！
指令重排的前提是，重排指令不能影响结果，例如
// 可以重排的例子
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 级流水线，但由于功耗太高被废弃
4.6诡异的结果
int num = 0;
boolean ready = false;
// 线程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 已经执行过了）
情况4：线程2 执行 ready = true，切换到线程1，进入 if 分支，相加为 0，再切回线程2 执行 num = 2
这种现象叫做指令重排，是 JIT 编译器在运行时的一些优化，这个现象需要通过大量测试才能复现：
创建 maven 项目，提供如下测试类
mvn archetype:generate -DinteractiveMode=false -DarchetypeGroupId=org.openjdk.jcstress -
DarchetypeArtifactId=jcstress-java-test-archetype -DarchetypeVersion=0.5 -DgroupId=cn.itcast -
DartifactId=ordering -Dversion=1.0
import org.openjdk.jcstress.annotations.*;
import org.openjdk.jcstress.infra.results.I_Result;
@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 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 1,652 ACCEPTABLE_INTERESTING !!!!
1 46,460,657 ACCEPTABLE ok
4 4,571,072 ACCEPTABLE ok
可以看到，出现结果为 0 的情况有 638 次，虽然次数相对很少，但毕竟是出现了。
解决方法 : volatile 修饰的变量，可以禁用指令重排
import org.openjdk.jcstress.annotations.*;
import org.openjdk.jcstress.infra.results.I_Result;
@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;
volatile 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;
// volatile修饰的变量之前的指令不会被重排序了
ready = true;
*** ERROR tests
Tests break for some reason, other than failing the assert. Correct implementations should have none.
0 matching test results.
4.7 volatile 原理
volatile 的底层实现原理是内存屏障，Memory Barrier（Memory Fence）
- 对 volatile 变量的读指令前会加入读屏障
- 对 volatile 变量的写指令后会加入写屏障
4.71.如何保证可见性
- 写屏障（sfence）保证在该屏障之前的，对共享变量的改动，都同步到主存当中
public void actor2(I_Result r)
num = 2;
ready = true; // ready 是 volatile 赋值带写屏障
// 写屏障 把vloatile之前的修改都同步到主存中
- 读屏障（lfence）保证在该屏障之后，对共享变量的读取，加载的是主存中最新数据
public void actor1(I_Result r)
// 读屏障
// ready 是 volatile 读取值带读屏障
if(ready)
r.r1 = num + num;
else
r.r1 = 1;
4.7.2.如何保证有序性
写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
public void actor2(I_Result r)
num = 2;
ready = true; // ready 是 volatile 赋值带写屏障
// 写屏障
读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前
public void actor1(I_Result r)
// 读屏障
// ready 是 volatile 读取值带读屏障
if(ready)
r.r1 = num + num;
else
r.r1 = 1;
volatile不能解决指令交错： 写屏障仅仅是保证之后的读能够读到最新的结果，但不能保证读跑到它前面去 而有序性的保证也只是保证了本线程内相关代码不被重排序
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LJXOGFWr-1666785851126)(C:\\Users\\14823\\Desktop\\learn-note\\typroa-img\\image-20211122173944100.png)]
4.7.3 double-checked locking
以著名的 double-checked locking 单例模式为例
public class Singleton
private Singleton()
private static Singleton INSTANCE = null;
public synchronized static Singleton getInstance()
if(INSTANCE == null)
// 首次访问会同步，而之后的使用没有 synchronized
synchronized(Singleton.class)
if (INSTANCE == null)
INSTANCE = new Singleton();
return INSTANCE;
以上的实现特点是：
- 懒惰实例化
- 首次使用 getInstance() 才使用 synchronized 加锁，后续使用时无需加锁
- 有隐含的，但很关键的一点：第一个 if 使用了 INSTANCE 变量，是在同步块之外
但在多线程环境下，上面的代码是有问题的，getInstance 方法对应的字节码为：
0: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
3: ifnonnull 37
6: ldc #3 // class cn/itcast/n5/Singleton
8: dup
9: astore_0
10: monitorenter
11: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
14: ifnonnull 27
17: new #3 // class cn/itcast/n5/Singleton
20: dup
21: invokespecial #4 // Method "<init>":()V
24: putstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
27: aload_0
28: monitorexit
29: goto 37
32: astore_1
33: aload_0
34: monitorexit
35: aload_1
36: athrow
37: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
40: aretur
// synchronized 可以保证：可见性，原子性，有序性[前提是改变量完全交给synchronized保护]
// 只有在 monitorenter 和 monitorexit 之间的代码才会保证有序性
其中
- 17 表示创建对象，将对象引用入栈 // new Singleton
- 20 表示复制一份对象引用 // 引用地址
- 21 表示利用一个对象引用，调用构造方法
- 24 表示利用一个对象引用，赋值给 static INSTANCE
- 也许 jvm 会优化为：先执行 24，再执行 21。如果两个线程 t1，t2 按如下时间序列执行：
-
关键在于 0: getstatic 这行代码在 monitor 控制之外，它就像之前举例中不守规则的人，可以越过 monitor 读取
INSTANCE 变量的值 -
这时 t1 还未完全将构造方法执行完毕，如果在构造方法中要执行很多初始化操作，那么 t2 拿到的是将是一个未初
始化完毕的单例 -
对 INSTANCE 使用 volatile 修饰即可，可以禁用指令重排，但要注意在 JDK 5 以上的版本的 volatile 才会真正有效
public class Singleton
private Singleton()
// 加上 volatile 关键字避免指令重排序
private static volatile Singleton INSTANCE = null;
public synchronized static Singleton getInstance()
if(INSTANCE == null) // t2
// 首次访问会同步，而之后的使用没有 synchronized
synchronized(Singleton.class)
if (INSTANCE == null) // t1
INSTANCE java并发编程之volatile