多线程教程（十九）JMM三大特性 原子性、可见性、有序性

多线程教程（十九）JMM三大特性

JMM 即 Java Memory Model，它定义了主存、工作内存抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、CPU 指令优化等。

JMM 体现在以下几个方面

• 原子性 - 保证指令不会受到线程上下文切换的影响

• 可见性 - 保证指令不会受 cpu 缓存的影响

• 有序性 - 保证指令不会受 cpu 指令并行优化的影响

1.可见性

（1）可能遇到的问题——退不出的循环

先来看一个现象，main 线程对 run 变量的修改对于 t 线程不可见，导致了 t 线程无法停止：

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不会如预想的停下来
}

（2）原因分析

1. 初始状态， t 线程刚开始从主内存读取了 run 的值到工作内存。

2. 因为 t 线程要频繁从主内存中读取 run 的值，JIT 编译器会将 run 的值缓存至自己工作内存中的高速缓存中，减少对主存中 run 的访问，提高效率

3. 1 秒之后，main 线程修改了 run 的值，并同步至主存，而 t 是从自己工作内存中的高速缓存中读取这个变量的值，结果永远是旧值

（3）解决方案

volatile（易变关键字）

它可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存

2.可见性 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 是属于重量级操作，性能相对更低

3.有序性

JVM 会在不影响正确性的前提下，可以调整语句的执行顺序，思考下面一段代码

static int i;
static int j;


// 在某个线程内执行如下赋值操作
i = ...; 
j = ...;

可以看到，至于是先执行 i 还是 先执行 j ，对最终的结果不会产生影响。所以，上面代码真正执行时，既可以是

i = ...; 
j = ...;

也可以是

j = ...;
i = ...;

这种特性称之为『指令重排』，多线程下『指令重排』会影响正确性。

（1）有序性带来的问题示例

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：线程1 先执行，这时 ready = false，所以进入 else 分支结果为 1

• 情况2：线程2 先执行 num = 2，但没来得及执行 ready = true，线程1 执行，还是进入 else 分支，结果为1

• 情况3：线程2 执行到 ready = true，线程1 执行，这回进入 if 分支，结果为 4（因为 num 已经执行过了）

指令重排造成的新的可能性：

• 情况四：线程2 执行 ready = true，切换到线程1，进入 if 分支，相加为 0，再切回线程2 执行 num = 2，结果为0；

趁着总结JMM的三大特性，总结下自己对于三大特性的理解：

1.原子性。

原子性，指的是一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程打断。

原子性问题产生的原因是因为上下文切换，当某些语句不是原子性（字节码层面可以拆分）的时候，就会因为上下文切换，造成语句出现问题。举例子就是常见的i++。

i++在字节码层面分为获取、局部变量赋值、自增、原变量赋值（可能不是很规范）。字节码层面可分割就造成了在获取结束后，可能有别的线程获取cpu资源，造成多线程问题。

2.可见性

可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

可见性问题产生的原因是cpu存在多级缓存，但是多级缓存对于不同线程之间并不共享，不共享就会造成线程之间不了解更改情况，将错误结果写入主内存（后面应该会总结计算机的三级缓存）。

3.有序性

程序执行的顺序按照代码的先后顺序执行

有序性问题产生的原因是操作系统的重排序，操作系统为了更快的处理性能会对字节码进行重排序，但是重排序会带来一些多线程问题，像上面有序性小节的问题就是一种可能性。解决方法就是加上屏障（violate、synchronized等都是带屏障的）

参考文献

并发之原子性、可见性、有序性