Java 内存模型
Java 内存模型(Java Memory Model,JMM)规定了一个线程能看到其他线程的哪些写入结果。单线程里,写完再读一定读到新值;多线程里,没有同步的话,另一个线程可能读到旧值,甚至看到的写入顺序和代码顺序不一样。
JMM 不要求你去推测缓存什么时候刷新,而是给出一套 happens-before 规则:只要两个动作之间能用这些规则连起来,后一个动作就一定能看到前一个的结果。会用这套规则推导,volatile、锁、线程池和并发队列为什么能安全传递数据,以及 sleep 为什么不行,就都能讲清楚了。
1. 面试核心
先记住这几条,再读正文- happens-before 规定动作之间的可见性和内存顺序,并且可以通过传递性把多次同步连起来。卡 · happens-before 规则
- 同一个 monitor 的解锁 happens-before 后续的加锁,所以解锁前的写入对加锁后的读取可见。
- 同一个 volatile 字段的写 happens-before 同步顺序中后续的读,可以用来发布在它之前写入的普通数据。
- 一个线程里的全部动作,happens-before 另一个线程成功检测到它终止之后的动作。
sleep和yield没有同步语义,等得再久也建立不了跨线程可见性。卡 · sleep 与 join 的同步边界
2. 跨线程可见性问题
一个线程先写数据、再写完成标志,另一个线程不一定按这个顺序看到结果。看两个普通字段:
int value;
boolean ready;
// Thread A
value = 42;
ready = true;
// Thread B
if (ready) {
System.out.println(value);
}
两个线程之间没有任何同步,所以 B 即使读到了 ready == true,也可能读到 value == 0。
原因是编译器、即时编译器(JIT)和处理器都可以在 JMM 允许的范围内调整执行顺序,比如把两次写入调换,或者让 B 一直读自己缓存里的旧值。所以分析多线程代码时,只把两个线程的源代码按各种顺序穿插一遍,会漏掉这类合法结果。正确的思路是先找出跨线程的同步关系,再推导哪些写入对读取可见。这个例子缺的,正是 value = 42 和 B 读取 value 之间的 happens-before 关系。
3. happens-before 规则
happens-before(常译为「先行发生」)是 JMM 定义的动作之间的关系:如果 A happens-before B,那么 B 一定能看到 A 的效果,并且在内存模型的顺序上,A 排在 B 前面。
常用的规则有下面几条,「先于」都表示 happens-before。其中 monitor 是每个 Java 对象关联的监视器,synchronized 就是靠它实现互斥的:
- 同一个线程里,前面的动作先于后面的动作(程序顺序规则)。
- 同一个 monitor 的解锁先于之后对它的加锁。
- 对一个 volatile 字段的写,先于同步顺序中之后对这个字段的读。
- 调用
start()先于新线程里的全部动作。 - 一个线程里的动作,先于另一个线程成功检测到它终止,比如
join()正常返回,或isAlive()返回false。 - 中断一个线程,先于其他线程检测到这次中断。
另外,对象字段的默认初始化(比如整数字段置为 0)也先于程序中的后续动作。
这些规则真正有用的地方在于传递性:A 先于 B,B 先于 C,就能推出 A 先于 C。于是可以把一个线程内的顺序和跨线程的同步接起来,一步步推出数据怎样从写入者传到读取者,下一节就是一个例子。
注意,happens-before 约束的是能观察到的结果,不是指令的实际执行顺序。只要最终观察到的结果满足约束,JVM 和处理器仍然可以做优化。
4. volatile 发布链
把第 2 节里的完成标志改成 volatile,就能通过它安全地发布之前写入的数据。下面的示例只发布一次,发布之后不再修改 value:
private int value;
private volatile boolean ready;
public void publish() {
value = 42;
ready = true;
}
public int consume() {
if (!ready) {
throw new IllegalStateException("not ready");
}
return value;
}
消费者读到 ready == true 时,可以这样一步步推导:
- 发布线程先执行
value = 42,再写ready = true。按程序顺序规则,前者先于后者。 - 对
ready的 volatile 写,先于消费者读到true的那次读。这一步把两个线程连了起来。 - 消费者读完
ready再读value,按程序顺序规则,前者先于后者。
三段连起来,由传递性可知 value = 42 先于消费者读取 value,所以 consume() 返回 42。
这条链要求写入者和读取者用的是同一个 volatile 字段。换成一个无关的 volatile 字段,第 2 步就接不上了。另外,发布只保证可见性,count++ 这样的复合更新仍然需要另外保证原子性,详见 volatile。
5. JUC 组件的交接语义
JUC(java.util.concurrent 包及其子包)里的并发工具,在提交任务、获取结果和交接数据时也定义了 happens-before 关系。用这些组件交接数据,可以直接利用下面的规则:
- 提交线程在把任务交给
Executor之前的动作,先于任务里的动作。 - 异步计算里的动作,先于另一个线程通过
Future.get()成功取得结果之后的动作。 - 把元素放进并发队列之前的动作,先于另一个线程取出这个元素之后的动作。
CountDownLatch每次countDown()之前的动作,先于另一个线程await()成功返回之后的动作。- 对同一个
Semaphore,release()之前的动作先于另一个线程成功acquire()之后的动作。
并发集合也有类似保证:放入元素之前的操作,先于另一个线程访问或移除这个元素之后的操作。所以这些组件除了调度线程,还负责让接收方看到交接前写入的数据。比如提交任务前给一个普通对象填好字段,任务里直接读就行,不需要为了这次交接把字段声明为 volatile。
这些规则只覆盖 API 约定的方向和时刻。比如发送方把消息放进队列之后又继续修改它,接收方读到的这些新修改就不在保证范围内,需要额外同步。
6. 数据竞争与顺序一致性
数据竞争是指两个线程访问同一个普通变量,至少有一个是写入,而这些冲突的访问之间没有 happens-before 顺序。第 2 节的 value 和 ready 就存在数据竞争。
JMM 保证,没有数据竞争的程序(正确同步的程序)表现为顺序一致性:可以把每个线程按程序顺序执行,再把多个线程的动作交错起来理解结果,不用考虑重排序。一旦存在数据竞争,就要把编译优化和 JMM 允许的重排序都考虑进去,结果很难推。所以排查可见性问题时,先找缺失的同步关系,再去分析具体的执行过程。
顺序一致性不等于业务逻辑正确。它仍然允许线程在业务操作中间交错:检查和更新如果分开同步,两步之间照样可能插进别的线程的操作。这种业务竞态的例子见 线程安全。
7. sleep 与 join 的同步边界
等得久和建立同步关系是两回事。Thread.sleep() 只是让当前线程暂停一段时间,yield() 只是提示调度器让出执行机会,两者都没有同步语义。晚几秒再读共享变量,JMM 也不保证能看到新值。
join 才有同步语义,但要看它是怎么返回的。对已经启动的线程,不带超时的 join() 正常返回,说明线程已经终止。带超时的 join(long) 返回时,目标线程可能还活着。对还没启动的线程调用 join(),会直接返回。只有确认线程已经结束,才能使用终止检测规则:
worker.start();
worker.join(100);
if (worker.isAlive()) {
throw new IllegalStateException("still running");
}
System.out.println(result);
示例最多等 100 毫秒,然后用 isAlive() 检查 worker 是否已经终止。还在运行就直接报错;isAlive() 返回 false 说明成功检测到了终止,这时再读 result。假设 result 只由 worker 写入,终止检测规则保证这里能看到它的最终写入。
8. 常见问题
8.1 happens-before 要求两个动作在时间上紧挨着吗?
不要求。happens-before 约束的是可见性和内存顺序,两个动作之间可以隔着大量其他动作。反过来,只是观察到两个动作在现实时间上有先后,也推不出跨线程可见性,还得有同步关系。
8.2 理解 JMM 时,需要推测缓存何时刷新吗?
不需要。推导正确性时,直接用 JMM 的同步关系就够了。JMM 规定的是允许观察到哪些结果,怎样实现这些约束是 JVM 和处理器的事,它们会用到内存屏障和缓存一致性机制,具体方式因实现而异。把 volatile 简化成「把所有变量刷新到主内存」,反而容易漏掉真正需要的那条发布关系,比如读写两端用的是不是同一个字段。
9. 面试题卡片
10. 参考资料
来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明