文档章节

可见性有序性,Happens-before来搞定

tan日拱一兵
 tan日拱一兵
发布于 09/17 08:17
字数 3307
阅读 14
收藏 0

写在前面

上一篇文章并发 Bug 之源有三,请睁大眼睛看清它们 谈到了可见性/原子性/有序性三个问题,这些问题通常违背我们的直觉和思考模式,也就导致了很多并发 Bug

  • 为了解决 CPU,内存,IO 的短板,增加了缓存,但这导致了可见性问题
  • 编译器/处理器擅自优化 ( Java代码在编译后会变成 Java 字节码, 字节码被类加载器加载到 JVM 里, JVM 执行字节码, 最终需要转化为汇编指令在 CPU 上执行) ,导致有序性问题

初衷是好的,但引发了新问题,最有效的办法就禁止缓存和编译优化,问题虽然能解决,但「又回到最初的起点,呆呆地站在镜子前」是很尴尬的,我们程序的性能就堪忧了.

解决方案

  1. 作为我们程序猿不想写出 bug 影响 KPI,所以希望内存模型易于理解、易于编程。这就需要基于一个强内存模型来编写代码
  2. 作为编译器和处理器不想让外人说它处理速度很慢,所以希望内存模型对他们束缚越少越好,可以由他们擅自优化,这就需要基于一个弱内存模型

俗话说:「没有什么事是开会解决不了的,如果有,那就再开一次」😂

JSR-133 的专家们就有了新想法,既然不能完全禁止缓存和编译优化,那就按需禁用缓存和编译优化,按需就是要加一些约束,约束中就包括了上一篇文章简单提到过的 volatile,synchronized,final 三个关键字,同时还有你可能听过的 Happens-Before 原则(包含可见性和有序性的约束),Happens-before 规则也是本章的主要内容

为了满足二者的强烈需求,照顾到双方的情绪,于是乎: JMM 就对程序猿说了一个善意的谎言: 「会严格遵守 Happpen-Befores 规则,不会重排序」让程序猿放心,私下却有自己的策略:

  1. 对于会改变程序执行结果的重排序,JMM要求编译器和处理器必须禁止这种重排序。
  2. 对于不会改变程序执行结果的重排序, JMM对编译器和处理器不做要求 (JMM允许这种重排序)。

我们来用个图说明一下:

这就是那个善意的谎言,虽是谎言,但还是照顾到了程序猿的利益,所以我们只需要了解 happens-before 规则就能得到保证 (图画了好久,不知道是否说明了谎言的所在😅,欢迎留言)

Happens-before

Happens-before 规则主要用来约束两个操作,两个操作之间具有 happens-before 关系, 并不意味着前一个操作必须要在后一个操作之前执行,happens-before 仅仅要求前一个操作(执行的结果)对后一个操作可见, (the first is visible to and ordered before the second)

说了这么多,先来看一小段代码带你逐步走进 Happen-Befores 原则,看看是怎样用该原则解决 可见性有序性 的问题:

class ReorderExample {
  int x = 0;
  boolean flag = false;
  public void writer() {
    x = 42;    //1
    flag = true;    //2
  }
  public void reader() {
    if (flag) { //3
      System.out.println(x);    //4
    }
  }
}

假设 A 线程执行 writer 方法,B 线程执行 reader 方法,打印出来的 x 可能会是 0,上一篇文章说明过: 因为代码 1 和 2 没有数据依赖关系,所以可能被重排序

flag = true;    //2
x = 42;    //1

所以,线程 A 将 flag = true 写入但没有为 x 重新赋值时,线程 B 可能就已经打印了 x 是 0

那么为 flag 加上 volatile 关键字试一下:

volatile boolean flag = false;

即便加上了 volatile 关键字,这个问题在 java1.5 之前还是没有解决,但 java1.5 和其之后的版本对 volatile 语义做了增强,问题得以解决,这就离不开 Happens-before 规则的约束了,总共有 6 个规则,且看

程序顺序性规则

一个线程中的每个操作, happens-before 于该线程中的任意后续操作 第一感觉这个原则是一个在理想状态下的"废话",并且和上面提到的会出现重排序的情况是矛盾的,注意这里是一个线程中的操作,其实隐含了「as-if-serial」语义: 说白了就是只要执行结果不被改变,无论怎么"排序",都是对的

这个规则是一个基础规则,happens-before 是多线程的规则,所以要和其他规则约束在一起才能体现出它的顺序性,别着急,继续向下看

volatile变量规则

对一个 volatile 域的写, happens-before 于任意后续对这个 volatile 域的读

我将上面的程序添加两行代码作说明:

public class ReorderExample {

	private int x = 0;
	private int y = 1;
	private volatile boolean flag = false;

	public void writer(){
		x = 42;	//1
		y = 50;	//2
		flag = true;	//3
	}

	public void reader(){
		if (flag){	//4
			System.out.println("x:" + x);	//5
			System.out.println("y:" + y);	//6
		}
	}
}

这里涉及到了 volatile 的内存增强语义,先来看个表格:

能否重排序 第二个操作 第二个操作 第二个操作
第一个操作 普通读/写 volatile 读 volatile 写
普通读/写 - - NO
volatile 读 NO NO NO
volatile 写 - NO NO

从这个表格 最后一列 可以看出:

如果第二个操作为 volatile 写,不管第一个操作是什么,都不能重排序,这就确保了 volatile 写之前的操作不会被重排序到 volatile 写之后 拿上面的代码来说,代码 1 和 2 不会被重排序到代码 3 的后面,但代码 1 和 2 可能被重排序 (没有依赖也不会影响到执行结果),说到这里和 程序顺序性规则是不是就已经关联起来了呢?

从这个表格的 倒数第二行 可以看出:

如果第一个操作为 volatile 读,不管第二个操作是什么,都不能重排序,这确保了 volatile 读之后的操作不会被重排序到 volatile 读之前 拿上面的代码来说,代码 4 是读取 volatile 变量,代码 5 和 6 不会被重排序到代码 4 之前

volatile 内存语义的实现是应用到了 「内存屏障」,因为这完全够单独写一章的内容,这里为了不掩盖主角 Happens-before 的光环,保持理解 Happens-before 的连续性,先不做过多说明

到这里,看这个规则,貌似也没解决啥问题,因为它还要联合第三个规则才起作用

传递性规则

如果 A happens-before B, 且 B happens-before C, 那么 A happens-before C 直接上图说明一下上面的例子

从上图可以看出

  • x =42y = 50 Happens-before flag = true, 这是规则 1
  • 写变量(代码 3) flag=true Happens-before 读变量(代码 4) if(flag),这是规则 2

根据规则 3传递性规则,x =42 Happens-before 读变量 if(flag)

谜案要揭晓了: 如果线程 B 读到了 flag 是 true,那么 x =42y = 50 对线程 B 就一定可见了,这就是 Java1.5 的增强 (之前版本是可以普通变量写和 volatile 变量写的重排序的)

通常上面三个规则是一种联合约束,到这里你懂了吗?规则还没完,继续看

监视器锁规则

对一个锁的解锁 happens-before 于随后对这个锁的加锁

这个规则我觉得你应该最熟悉了,就是解释 synchronized 关键字的,来看

public class SynchronizedExample {
	private int x = 0;

	public void synBlock(){
		// 1.加锁
		synchronized (SynchronizedExample.class){
			x = 1; // 对x赋值
		}
		// 3.解锁
	}

	// 1.加锁
	public synchronized void synMethod(){
		x = 2; // 对x赋值
	}
	// 3. 解锁
}

先获取锁的线程,对 x 赋值之后释放锁,另外一个再获取锁,一定能看到对 x 赋值的改动,就是这么简单,请小伙伴用下面命令查看上面程序,看同步块和同步方法被转换成汇编指令有何不同?

javap -c -v SynchronizedExample

这和 synchronized 的语义相关,小伙伴可以先自行了解一下,锁的内容时会做详细说明

start()规则

如果线程 A 执行操作 ThreadB.start() (启动线程B), 那么 A 线程的 ThreadB.start() 操作 happens-before 于线程 B 中的任意操作,也就是说,主线程 A 启动子线程 B 后,子线程 B 能看到主线程在启动子线程 B 前的操作,看个程序就秒懂了

public class StartExample {
	private int x = 0;
	private int y = 1;
	private boolean flag = false;

	public static void main(String[] args) throws InterruptedException {
		StartExample startExample = new StartExample();

		Thread thread1 = new Thread(startExample::writer, "线程1");
		startExample.x = 10;
		startExample.y = 20;
		startExample.flag = true;

		thread1.start();

		System.out.println("主线程结束");
	}

	public void writer(){
		System.out.println("x:" + x );
		System.out.println("y:" + y );
		System.out.println("flag:" + flag );
	}
}

运行结果:

主线程结束
x:10
y:20
flag:true

Process finished with exit code 0

线程 1 看到了主线程调用 thread1.start() 之前的所有赋值结果,这里没有打印「主线程结束」,你知道为什么吗?这个守护线程知识有关系

join()规则

如果线程 A 执行操作 ThreadB.join() 并成功返回, 那么线程 B 中的任意操作 happens-before 于线程 A 从 ThreadB.join() 操作成功返回,和 start 规则刚好相反,主线程 A 等待子线程 B 完成,当子线程 B 完成后,主线程能够看到子线程 B 的赋值操作,将程序做个小改动,你也会秒懂的

public class JoinExample {
	private int x = 0;
	private int y = 1;
	private boolean flag = false;

	public static void main(String[] args) throws InterruptedException {
		JoinExample joinExample = new JoinExample();

		Thread thread1 = new Thread(joinExample::writer, "线程1");
		thread1.start();

		thread1.join();

		System.out.println("x:" + joinExample.x );
		System.out.println("y:" + joinExample.y );
		System.out.println("flag:" + joinExample.flag );
		System.out.println("主线程结束");
	}

	public void writer(){
		this.x = 100;
		this.y = 200;
		this.flag = true;
	}
}

运行结果:

x:100
y:200
flag:true
主线程结束

Process finished with exit code 0

「主线程结束」这几个字打印出来喽,依旧和线程何时退出有关系

总结

  1. Happens-before 重点是解决前一个操作结果对后一个操作可见,相信到这里,你已经对 Happens-before 规则有所了解,这些规则解决了多线程编程的可见性与有序性问题,但还没有完全解决原子性问题(除了 synchronized)
  2. start 和 join 规则也是解决主线程与子线程通信的方式之一
  3. 从内存语义的角度来说, volatile 的写-读与锁的释放-获取有相同的内存效果;volatile 写和锁的释放有相同的内存语义; volatile 读与锁的获取有相同的内存语义,⚠️⚠️⚠️(敲黑板了) volatile 解决的是可见性问题,synchronized 解决的是原子性问题,这绝对不是一回事,后续文章也会说明

附加说明

  1. 访问个人博客 https://dayarch.top/ 提前发现更多精彩
  2. 多线程系列文章整体会按照我的大纲节奏来写,但是如果大家有什么疑问,也欢迎到我单独建立的多线程系列问题留言汇总 文章中留言,我会统一回复,如果共通疑问很多,我会插入相关章节单独做说明
  3. 并发文章的相关代码,我也会同步上传到代码库,公众号回复「demo」,点击链接,找到concurrency 子项目即可
  4. 如果文章对你有帮助,烦请小伙伴转发分享给更多朋友,我们一起进步

灵魂追问

  1. 同步块和同步方法在编译成 CPU 指令后有什么不同?
  2. 线程有 Daemon(守护线程)和非 Daemon 线程,你知道线程的退出策略吗?
  3. 关于 Happens-before 你还有哪些疑惑呢?

提高效率工具

MarkDown 表格生成器

本文的好多表格是从官网粘贴的,如何将其直接转换成 MD table 呢?那么 https://www.tablesgenerator.com/markdown_tables 就可以帮到你了,无论是生成 MD table,还是粘贴内容生成 table 和内容都是极好的,当然了不止 MD table,自己发现吧,更多工具,公众号回复 「工具」获得


推荐阅读


欢迎持续关注公众号:「日拱一兵」

  • 前沿 Java 技术干货分享
  • 高效工具汇总 | 回复「工具」
  • 面试问题分析与解答
  • 技术资料领取 | 回复「资料」

以读侦探小说思维轻松趣味学习 Java 技术栈相关知识,本着将复杂问题简单化,抽象问题具体化和图形化原则逐步分解技术问题,技术持续更新,请持续关注......

© 著作权归作者所有

tan日拱一兵

tan日拱一兵

粉丝 0
博文 29
码字总数 68193
作品 0
大连
私信 提问
「原创」Java并发编程系列04 Java内存模型详解

     思维导图      写在前面   前面讲解了并发编程的三大核心问题:原子性、可见性、有序性。文章见:【原创】Java并发编程系列03 | 重排序-可见性和有序性问题根源   那么,作...

java进阶架构师
10/10
0
0
面试官最爱的volatile关键字

在Java相关的岗位面试中,很多面试官都喜欢考察面试者对Java并发的了解程度,而以volatile关键字作为一个小的切入点,往往可以一问到底,把Java内存模型(JMM),Java并发编程的一些特性都牵...

卡巴拉的树
2017/12/11
0
0
并发二:JAVA内存模型

Java Memory Model JAVA内存模型(Java Memory Model 简称JMM),定义了程序中各个共享变量的访问规则。 Java Memory Model 程序中的变量都存储在主内存中,而每个线程拥有自己的工作内存用来...

wangjie2016
2017/05/19
0
0
Java 开发, volatile 你必须了解一下

并发的三个特性 首先说我们如果要使用 volatile 了,那肯定是在多线程并发的环境下。我们常说的并发场景下有三个重要特性:原子性、可见性、有序性。只有在满足了这三个特性,才能保证并发程...

Java工程师-Distance
2018/05/22
75
0
从单例模式到Happens-Before

本文已同步到http://liumian.win/2016/12/14/fromsingletontohappens-before/ 本文主要从简单的单例模式为切入点,分析单例模式可能存在的一些问题,以及如何借助Happens-Before分析、检验代...

那只是一股逆流
2016/12/14
447
0

没有更多内容

加载失败,请刷新页面

加载更多

springboot配置文件读取pom文件信息

解决的问题 springboot(当然别的也可以)多环境切换需要该配置文件,打包时不够方便。 解决: 配置文件能读取pom文件中的配置,根据命令选择不同配置注入springboot的配置文件中 pom配置文件...

刘一草
14分钟前
3
0
蓝牙自定开锁时间--Python

from Crypto.Cipher import AESfrom binascii import b2a_hex, a2b_hex###强制输入明文增加到16字节的倍数,在末尾补'\0'def add_to_16(text): text = str(text, 'ISO-8859-1'......

丁典
14分钟前
3
0
好程序员web前端教程分享JS基础知识

  好程序员web前端教程分享JS基础知识,为大家分享一篇关于JS的基础知识。   1、执行环境:有时也叫环境,是JavaScript中最为重要的一个概念,执行环境定义了变量或函数有权访问的其他数...

好程序员官网
17分钟前
2
0
kali和win共享文件夹设置

卸载vmtools > whereis vmware-tools /etc/vmware-tools/ /usr/lib/vmware-tools/> cd /etc> sudo rm -r vmware-tools> cd /usr/lib> sudo rm -r vmware-tools 先添加源 leafpa......

yeahlife
18分钟前
2
0
killall 、kill 、pkill 命令区别

killall 命令Linux系统中的killall命令用于杀死指定名字的进程(kill processes by name)。我们可以使用kill命令杀死指定进程PID的进程,如果要找到我们需要杀死的进程, 我们还需要在之前使...

突突突酱
26分钟前
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部