(拉钩)Android工程师进阶34讲-07:Java内存模型与线程

0. 前言

Java内存模型翻译自Java Memory Model,简称JMM,它所描述的是多线程并发、CPU缓存等方面的内容。

1. 为什么有Java内存模型

很多介绍JMM时,会借用《深入理解Java虚拟机》中的一张图。

上图描述的意思是,在每一个线程中,都会有一块内部的工作内存(working memory)。这块工作内存保存了主内存共享数据的拷贝副本。第一节中,了解到JVM内存结构中有一块线程独享的内存空间——虚拟机栈,这里自然而然就会将线程工作内存理解成虚拟机栈。

但是,这是不准确的!虚拟机栈和线程的工作内存并不是一个概念。在Java线程中并不存在所谓的工作内存,它只是对CPU寄存器和高速缓存的抽象描述

1.1 CPU普及

线程是CPU调度的最小单位,线程中的字节码指令最终都是在CPU中执行的。CPU在执行的时候,免不了要和各种数据打交道,而Java中所有数据都存放在主内存(RAM)中的,这一过程可以参考下图:

随着CPU技术的发展,CPU的执行速度越来越快,但内存的技术并没有太大变化,所以在内存中读取和写入数据的过程和CPU的执行速度比起来差距会越来越大。CPU对主内存的访问需要等待较长时间,这样就体现不出CPU超强的运算能力的优势了。

为了“压榨”处理性能,达到“高并发”的效果,在CPU中添加高速缓存(cache)来作为缓冲。

在执行任务时,CPU会先将运算所需要使用到的数据复制到高速缓存中,让运算能快速进行,当运算完成之后,再将缓存中的结果刷回(flush back)主内存,这样CPU就不用等待主内存的读写操作了。

但是这样也有问题。每个处理器都有自己的高速缓存,同时又共同操作同一块主内存,当多个处理器同时操作主内存时,可能导致数据不一致,这就是缓存一致性问题。

1.2 缓存一致性问题

现在市面上手机通常有两个或多个CPU,一些CPU还有多核。每个CPU在某一时刻都能运行一个线程,这意味着,如果Java程序是多线程的,那么就有可能存在多个线程在同一时刻被不同CPU执行的情况。

如下代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public int x = 0;
public int y = 0;

Thread t1 = new Thread() {
@Override
public void run() {
int r1 = x;
y = 1;
}
};

Thread t2 = new Thread() {
@Override
public void run() {
int r2 = y;
x = 2;
}
};

t1.start();
t2.start();

定义两个变量xy,初始值都为0。

在线程t1中,将x赋值给r1,然后将y设置为1。

在线程t2中,将y赋值给r2,然后将x设置为2。

假设一台设备上有2个CPU,分别为C1和C2,将上面这段代码在这台设备上执行,最后打印r1r2的值分别为多少?答案是不确定。

情况1:

假设t1现在C1中执行完毕,并成功刷回主内存中,此时r1 = 0x = 0y = 1

然后t2在C2中执行,从主内存中加载y = 1并赋值给r2,此时r2 = 1x = 2y = 1

情况2:

假设t2现在C1中执行完毕,并成功刷回主内存中,此时r2 = 0x = 2y = 0

然后t1在C2中执行,从主内存中加载y = 1并赋值给r2,此时r1 = 2x = 2y = 1

情况3:

xy的值分别缓存在C1和C2的缓存中。

首先t1在C1中执行完毕,但是没有将结果刷回主内存中,此时主内存中x = 0y = 0

然后t2在C2中执行,缓存中的y = 0,并将其赋值给r2,此时r2 = 0x = 2y = 1

如下图:

可以看出,虽然在C1和C2的缓存中,分别修改了xy的值,但是并未将它刷回主内存中,这就是缓存一致性问题。

1.3 指令重排

除了缓存一致性问题,还有另外一个硬件问题:为了使CPU内部的运算单元能尽量被充分利用,处理器可能会对输入的字节码指令进行重排序处理,也就是处理器优化。除了CPU之外,很多编程语言的编译器也会有类似的优化,比如Java虚拟机的即使编译(JIT)也会做指令重排。

以下面代码为例:

编译之后的字节码指令如下:

可以看出,在上述指令中,有两处指令表达的是同样的语义,并且指令7并不依赖指令2和指令3。在这种情况下,CPU会对指令的顺序做优化,如下:

从Java是语言的角度看这层优化就是:

也就是说在CPU层面,有时代码并不会严格按照Java文件中的顺序执行。再看一下之前r1/r2的实例,刚才分析了会有三种情况发生,其实在极端情况下,还会出现第4种情况:

r1 = 2r2 = 1

线程t2中的代码经过CPU优化之后,会被重排为:

经过优化之后,t2线程将x赋值为2,这时CPU将时间片段分配给线程t1,线程t1在执行过程中,将r1赋值为x,此时x = 2,所以r1 = 2。然后将y赋值为1,此时CPU再将时间片段重新分配给t2

代码回到t2中,将y赋值给r2,此时y = 1,所以r2 = 1,整个过程如下图:

上面两小部分的内容表明,如果任由CPU优化或编译器指令重排,那编写的Java代码最终执行效果可能会出现偏差。为了解决这个问题,让Java在不同硬件、不同操作系统中,输出的结果达到一致,Java虚拟机规范了一套机制——Java内存模型。

2. 什么是内存模型

内存模型是一套共享内存中多线程读写操作行为的规范,这套规范屏蔽了底层各种硬件和操作系统的内存访问差异,解决了CPU多级缓存、CPU优化、指令重排等导致的内存访问问题,从而保证Java程序(尤其是多线程程序)在各种平台下对内存的访问效果一致。

在Java内存模型中,统一用工作内存(working memory)来当做CPU中寄存器或高速缓存的抽象。线程之间的共享变量存储在主内存(main memory)中,每个线程都有一个私有的工作内存(类比CPU中的寄存器或高速缓存),本地工作内存中存储了该线程读/写共享变量的副本。

这套规范中有一个非常重要的规则——happens-before。

happens-before 先行发生原则

happens-before用于描述两个操作的内存可见性,通过保证可见性的机制可以让应用程序免于数据竞争干扰。它的定义如下:

如果一个操作A happens-before 另一个操作B,那么操作A的执行结果将对操作B可见。

上述定义也可以反过来理解:如果操作A的结果需要对另一个操作B可见,那么操作A必须happens-before 操作B。

用以下代码举例:

1
2
3
4
5
6
7
8
9
private int value = 0;

public void setValue(int value) {
value = 1;
}

public int getValue() {
return value;
}

假设setValue就是操作A,getValue就是操作B。如果先后在两个线程中调用A和B,那最后在B操作中返回的value值是多少呢?有以下两种情况:

如果 A happens-before B不成立

也就是说当线程调用操作B(getValue)时,即使操作A(setValue)已经在其他线程中被调用过,并且value也被成功设置为1,但这个修改对于操作B(getValue)仍然是不可见的。根据之前介绍的CPU缓存,value值有可能返回0,也可能返回1。

如果 A happens-before 成立

根据 happens-before 的定义,先行发生动作的结果,对后续发生动作是可见的。也就是说如果先在一个线程中调用操作A(setValue),那个这个修改的结果对后续的操作B(getValue)始终可见。因此先调用setValuevalue赋值1之后,后续在其他线程中调用getValue的值一定是1。

那么Java中两个操作如何就算符合 happens-before 规则呢?JMM中定义了以下几种情况实时自动符合 happens-before 规则的:

程序次序规则

在单线程内部,如果一段代码的字节码顺序也隐式符合 happens-before 原则,那么逻辑顺序靠前的字节码执行结果一定对后续逻辑字节码可见,只是后续逻辑中不一定用到而已。比如下面代码:

1
2
int a = 10; // 1
b = b + 1; // 2

当代码执行到2时,a = 10这个结果已经可见,至于用没用到a这个结果,则不一定。比如上面的代码就没用到,说明ba的结果没有依赖,这样就有可能发生指令重排。

但如果将代码修改如下,就不会发生指令重排优化:

1
2
int a = 10; // 1
b = b + a; // 2

锁定规则

无论在单线程环境还是多线程环境,一个锁如果处于被锁状态,那么必须先执行unlock操作后才能进行lock操作。

变量规则

volatile保证了线程可见性。通俗讲就是如果一个线程先写了一个volatile变量,然后另外一个线程去读这个变量,那么这个写操作一定是 happens-before 读操作的。

线程启动规则

Thread对象的start()方法先行发生于此线程的每个动作。假定线程A执行过程中,通过执行ThreadB.start()来启动线程B,那么线程A对共享变量的修改在线程B开始执行后确保对线程B可见。

线程中断规则

对线程interrupt()方法的调用先行发生于被中断线程的代码检测,直到中断事件的发生。

线程终结规则

线程中所有的操作都发生在线程的终止检测之前,可以通过Thread.join()方法结束、Thread.isAlive()的返回值等方法检测线程是否终止执行。假定线程A在执行过程中,通过调用Thread.join()等待线程B终止,那么线程B在终止之前对共享变量的修改在线程A等待返回后可见。

对象终结规则

一个对象的初始化完成发生在它的finalize()方法开始之前。

此外,happens-before 原则还具有传递性L如果操作 A happens-before 操作B,而操作 B happens-before 操作 C,则操作 A happens-before 操作 C。

3. Java内存模型的应用

上面介绍的 happens-before 原则很重要,它是判断数据是否存在竞争、线程是否安全的主要依据,根据这个原则,可以解决在并发环境下操作之间是否可能存在冲突的问题。在此基础上,可以通过Java提供的一系列关键字,实现多线程操作 “happens-before化”。

3.1 使用volatile修饰value

1
2
3
4
5
6
7
8
9
private volatile int value = 0;

public void setValue(int value) {
value = 1;
}

public int getValue() {
return value;
}

3.2 使用synchronized关键字

1
2
3
4
5
6
7
8
9
10
11
12
13
private int value = 0;

public void setValue(int value) {
synchronized (this) {
value = 1;
}
}

public int getValue() {
synchronized (this) {
return value;
}
}

通过以上两种方式,都可以使setValuegetValue符合 happens-before 原则——当在某一线程中调用setValue后,再在其他线程中调用getValue获取的值一定是1。

4. 总结

  • Java内存模型的来源:主要是因为CPU缓存和指令重排等优化导致多线程程序结果不可控。
  • Java内存模型是什么:本质上它是一套规范,在这套规范中有一条最重要的 happens-before 原则。
  • Java内存模型的使用,介绍了两种方式:volatilesynchronized。除了这两种方法,Java还提供了很多关键字来实现 happens-before 原则,会在后面介绍。
  • Copyrights © 2019-2020 Tyler Liu

请我喝杯咖啡吧~

支付宝
微信