一、Java 内存模型
JMM 即 Java Memory Model，它定义了主存、工作内存抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、CPU 指令优化等。JMM 体现在以下几个方面。
1、原子性：保证指令不会受到线程上线文切换的影响。
2、可见性：保证指令不会受 CPU 缓存的影响。
3、有序性：保证指令不会受 CPU 指令并行优化的影响。
二、原子性
synchronized 中的 monitor 主要关注的就是线程访问共享变量时，保证了临界区代码的原子性。
三、可见性
3.1 现象展示
先执行下面的代码，可以看到 main 线程对 run 变量的修改对于 t 线程不可见，导致 t 线程无法停止。
@Slf4j(topic = "c.test")
public class Main8 {
static boolean run = true;
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
while(run){
// ....
}
});
t.start();
Thread.sleep(1000);
run = false; // 线程t不会如预想的停下来
}
}
3.2 原因分析
初始状态下，t 线程刚开始从主内存读取了 run 的值到工作内存。如下图：
因为 t 线程要频繁从主内存中读取 run 的值，JIT 编译器会将 run 的值缓存至自己工作内存中的高速缓存中，减少对主存中 run 的访问，提高效率 ，如下图：
1 秒之后，main 线程修改了 run 的值，并同步至主存，而 t 是从自己工作内存中的高速缓存中读取这个变量的值，结果永远是旧值，如下图：
3.3 解决方式
解决的办法是使用 volatile 关键字，它可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存，如下代码：
@Slf4j(topic = "c.test")
public class Main8 {
volatile static boolean run = true;
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
while(run){
// ....
}
});
t.start();
Thread.sleep(1000);
run = false; // 线程t不会如预想的停下来
}
}
3.4 原子性和可见性对比
上面的例子体现的实际上就是可见性，它保证的是在多个线程之间，一个线程对 volatile 变量的修改对另外一个线程可见，但是不能保证原子性，仅用在一个写线程，多个读线程的场景下。
synchronized 语句块既可以保证代码的原子性，也同时保证代码块内变量的可见性。但缺点是 synchronized 是属于重量级操作，性能相对较低。
四、有序性
4.1 指令重排
JVM 会在不影响正确性的前提下，可以调整语句的执行顺序，思考下面一段代码：
static int i;
static int j;
// 在某个线程内执行如下赋值操作
i = ...;
j = ...;可以看到，至于是先执行 i 还是先执行 j ，对最终的结果不会产生影响。所以，上面代码真正执行时，既可以是
i = ...;
j = ...;也可以是：
j = ...;
i = ...;这种特性称之为指令重排，多线程下指令重排会影响正确性。为什么要有重排指令这项优化呢？是因为指令重排可以 CPU 的利用率。
I_Result 是一个对象，有一个属性 r1 来保存结果，思考下，可能的结果有几种？
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;
}情况一：线程1 先执行，这时 ready = false，所以进入 else 分支结果为 1
情况二：线程2 先执行 num = 2，但没来得及执行 ready = true，线程1 执行，还是进入 else 分支，结果为 1。
情况三：线程2 执行到 ready = true，线程1 执行，这回进入 if 分支，结果为 4（因为 num 已经执行过了） 。
其实还有一种运行情况，结果还有可能是 0，这种情况是：线程2 执行 ready = true，切换到线程1，进入 if 分支，相加为 0，再切回线程2 执行 num = 2，这种现象叫做指令重排，是 JIT 编译器在运行时的一些优化，这个现象需要通过大量测试才能复现。
4.2 现象展示
如果想复现这个现象，需要借助 java 并发的压测工具 jcstress，首先创建一个 maven 工程，并添加如下的 maven 依赖：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>MavenTest</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<jcstress.version>0.5</jcstress.version>
<javac.target>1.8</javac.target>
<uberjar.name>jcstress</uberjar.name>
</properties>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.openjdk.jcstress/jcstress-core -->
<dependency>
<groupId>org.openjdk.jcstress</groupId>
<artifactId>jcstress-core</artifactId>
<version>0.3</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<compilerVersion>${javac.target}</compilerVersion>
<source>${javac.target}</source>
<target>${javac.target}</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>2.2</version>
<executions>
<execution>
<id>main</id>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<finalName>${uberjar.name}</finalName>
<transformers>
<transformer
implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<mainClass>org.openjdk.jcstress.Main</mainClass>
</transformer>
<transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
<resource>META-INF/TestList</resource>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>然后添加一个测试类，代码如下：
import org.openjdk.jcstress.annotations.*;
import org.openjdk.jcstress.infra.results.I_Result;
/**
* @author XHF
* @create 2024/7/17 -- 20:48
*/
@JCStressTest
//@Outcome 表示将来有可能的输出结果，当输出 1 和 4 时表示是我们可以接受的结果，如果是 0 则是我们感兴趣的结果
@Outcome(id = {"1","4"}, expect = Expect.ACCEPTABLE,desc = "ok")
@Outcome(id = "0",expect = Expect.ACCEPTABLE_INTERESTING,desc = "danger")
@State
public class Test03Orderliness {
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
等到打包成功之后，切换到 target 目录下，执行下面的命令：
java -jar jcstress.jar
此时就会输出我们感兴趣的结果，如下图所示：
4.3 解决方式
解决方式就是使用 volatile 修饰变量，可以禁止指令重排，如下代码：
import org.openjdk.jcstress.annotations.*;
import org.openjdk.jcstress.infra.results.I_Result;
/**
* @author XHF
* @create 2024/7/17 -- 20:48
*/
@JCStressTest
//@Outcome 表示将来有可能的输出结果，当输出 1 和 4 时表示是我们可以接受的结果，如果是 0 则是我们感兴趣的结果
@Outcome(id = {"1","4"}, expect = Expect.ACCEPTABLE,desc = "ok")
@Outcome(id = "0",expect = Expect.ACCEPTABLE_INTERESTING,desc = "danger")
@State
public class Test03Orderliness {
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;
ready = true;
}
}
记得重新编译打包，然后运行，输出结果如下所示，可以看到并未产生 0 的结果。
4.4 注意
我们只在 ready 前面添加了 volatile 关键字，并没有在 num 前面加关键字，那是因为在 actor2() 方法中，给 ready 加上之后，可以防止他前面的代码被重排序，所以加一个就可以了。
673
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
