Java 内存模型之重排序

揭秘Java内存模型:指令重排序的那些事儿 指令重排序,顾名思义,就是指处理器在执行程序指令时,改变了原本顺序的行为。这种现象看似奇怪,但在大多数情况下,它对程序员的影响是微乎其微的,尤其是在单线程环境下。可是,重排序在多线程环境中,却会带来非常大的困扰。1. 处理器层面的重排序我们先从硬件层面来了解一下重排序。现代的处理器为了提高性能,采用了指令流水线技术。所谓流水线,就是将多个指令的执行分成多个阶段,同时执行,从而提高处理器的执行效率。为了让指令能够更高效地执行,处理器会尝试对指令的执行顺序进行一定的调整,这就是指令重排序。 阅读详情

http://www.iocoder.cn/JUC/sike/jmm-1/

在执行程序时,为了提高性能,处理器和编译器常常会对指令进行重排序,但是不能随意重排序,不是你想怎么排序就怎么排序,它需要满足以下两个条件:

  1. 在单线程环境下,不能改变程序运行的结果。
  2. 存在数据依赖关系的情况下,不允许重排序。

如果看过 LZ 上篇博客的就会知道,其实这两点可以归结于一点:无法通过 happens-before 原则推导出来的,JMM 允许任意的排序。

1. as-if-serial 语义

as-if-serial 语义的意思是:所有的操作均可以为了优化而被重排序,但是你必须要保证重排序后执行的结果不能被改变,编译器、runtime、处理器都必须遵守 as-if-serial 语义。注意,as-if-serial 只保证单线程环境,多线程环境下无效。

下面我们用一个简单的示例来说明:

int a = 1 ;      // A
int b = 2 ;      // B
int c = a + b;   // C

A、B、C 三个操作存在如下关系:A、B 不存在数据依赖关系,A和C、B和C存在数据依赖关系,因此在进行重排序的时候,A、B 可以随意排序,但是必须位于 C 的前面,执行顺序可以是 A –> B –> C 或者 B –> A –> C 。但是无论是何种执行顺序最终的结果 C 总是等于 3 。

as-if-serail 语义把单线程程序保护起来了,它可以保证在重排序的前提下程序的最终结果始终都是一致的。

其实,对于上段代码,他们存在这样的 happen-before 关系:

  1. A happens-before B
  2. B happens-before C
  3. A happens-before C

1、2 是程序顺序次序规则,3 是传递性。但是,不是说通过重排序,B 可能会排在 A 之前执行么,为何还会存在存在 A happens-before B 呢?这里再次申明 A happens-before B 不是 A 一定会在 B 之前执行,而是 A 的执行结果对 B 可见,但是相对于这个程序 A 的执行结果不需要对 B 可见,且他们重排序后不会影响结果,所以 JMM 不会认为这种重排序非法。

我们需要明白这点:在不改变程序执行结果的前提下,尽可能提高程序的运行效率。

下面我们在看一段有意思的代码:

public class RecordExample1 {

    public static void main(String[] args){
        int a = 1;
        int b = 2;

        try {
            a = 3;           // A
            b = 1 / 0;       // B
        } catch (Exception e) {

        } finally {
            System.out.println("a = " + a);
        }
    }
    
}

按照重排序的规则,操作 A 与操作 B 有可能会进行重排序,如果重排序了,B 会抛出异常( / by zero),此时A语句一定会执行不到,那么 a 还会等于 3 么?如果按照 as-if-serial 原则它就改变了程序的结果。
其实,JVM 对异常做了一种特殊的处理,为了保证 as-if-serial 语义,Java 异常处理机制对重排序做了一种特殊的处理:JIT 在重排序时,会在catch 语句中插入错误代偿代码(a = 3),这样做虽然会导致 catch 里面的逻辑变得复杂,但是 JIT 优化原则是:尽可能地优化程序正常运行下的逻辑,哪怕以 catch 块逻辑变得复杂为代价。

2. 重排序对多线程的影响

在单线程环境下,由于 as-if-serial 语义,重排序无法影响最终的结果,但是对于多线程环境呢?

如下代码(volatile的经典用法):

public class RecordExample2 {
    
    int a = 0;
    boolean flag = false;

    /**
     * A线程执行
     */
    public void writer() {
        a = 1;                  // 1
        flag = true;            // 2
    }

    /**
     * B线程执行
     */
    public void read(){
        if (flag) {                 // 3
           int i = a + a;          // 4
        }
    }

}

A 线程先执行 #writer(),线程 B 后执行 #read(),线程 B 在执行时能否读到 a = 1 呢?答案是不一定(注:x86 CPU 不支持写写重排序,如果是在 x86 上面操作,这个一定会是 a = 1 , LZ 搞了好久都没有测试出来,最后查资料才发现)。

由于操作 1 和操作 2 之间没有数据依赖性,所以可以进行重排序处理。
操作 3 和操作 4 之间也没有数据依赖性,他们亦可以进行重排序,但是操作 3 和操作 4 之间存在控制依赖性。
假如操作1 和操作2 之间重排序:

重排序例子

  • 按照这种执行顺序线程 B 肯定读不到线程 A 设置的 a 值,在这里多线程的语义就已经被重排序破坏了。

实际上,操作 3 和操作 4 之间也可以重排序,虽然他们之间存在一个控制依赖的关系,只有操作 3 成立操作 4 才会执行。当代码中存在控制依赖性时,会影响指令序列的执行的并行度,所以编译器和处理器会采用猜测执行来克服控制依赖对并行度的影响。假如操作 3 和操作 4 重排序了,操作 4 先执行,则先会把计算结果临时保存到重排序缓冲中,当操作 3 为真时,才会将计算结果写入变量 i 中。

通过上面的分析,重排序不会影响单线程环境的执行结果,但是会破坏多线程的执行语义。

参考资料

  1. 周志明:《深入理解 Java 虚拟机》
  2. 方腾飞:《Java 并发编程的艺术》的 「3. Java 内存模型」 章节。

666. 彩蛋

整理本小节,简单脑图如下:脑图

评价模型——层次分析法(AHP)与熵权法(EWM) 层次分析法是定性与定量结合的多准则决策、评价方法。将决策的有关元素分解成目标层、准则层和方案层,并通过人们的判断对决策方案的优劣进行排序,在此基础上进行定性和定量分析。它把人的思维过程层次化、数量化,并用数学为分析、决策、评价、预报和控制提供定量的依据。 阅读详情

相关推荐

网格聚类 Grid Clustering/Grid-based Clustering

本文主要简单介绍了网格聚类的基本概念,优缺点,应用场景,建模时的注意事项,评价指标,实现方法,python示例和模型参数等。

JasonH2021的博客 4829

深入理解Java内存模型(二)——重排序

数据依赖性 如果两个操作访问同一个变量,且这两个操作中有一个为写操作,此时这两个操作之间就存在数据依赖性。数据依赖分下列三种类型: 名称 代码示例 说明 写后读 a = 1;b = a; 写一个变量之后,再读这个位置。 写后写 a = 1;a = 2; 写一个变量之后,再写这个变量。 读后写 a = b;b = 1; 读一个变量之后,...

怀素的专栏 774

通过 Android Framework 调用高通 Perf HAL 实现 CPU/GPU 动态调频策略

本文详细介绍了如何通过Android Framework调用高通Perf HAL实现CPU/GPU动态调频策略。文章涵盖HAL交互原理、环境搭建、Power HAL接口实现、PerformanceHintManager应用及温度功耗平衡处理,帮助开发者安全高效地进行性能优化,避免直接操作底层硬件的风险。

keras9composer的博客 259

Java内存模型中的重排序

重排序是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段。 数据依赖性 定义:如果两个操作访问同一个变量,且这两个操作中有一个为写操作,此时这两个操作之间就存在数据依赖性。 数据依赖分为三种类型:写后读、写后写和读后写。这三种类型,只要重排序两个操作间的执行顺序,程序的执行结果就会被改变。 编译器和处理器在做重排序时,会遵守数据依赖性,也就是说编译器和处理器不会改变存在数据依赖关系的两个操作的执行顺序。 这里所说的数据依赖性仅针对单个处理器中执行的指令序列和单个线程中执行的操作

weixin_45183912的博客 430

清华开源GPGPU“承影Ventus”初体验:用RISC-V RVV指令集跑通第一个OpenCL程序

本文详细介绍了清华大学开源GPGPU“承影Ventus”的开发实践,展示了如何基于RISC-V RVV指令集运行首个OpenCL程序。从环境配置、内核开发到性能优化,全面解析了这一创新架构的开发流程,为开发者提供了在RISC-V生态中进行通用GPU计算的实用指南。

weixin_30415113的博客 491

西门子交换机环网冗余设置(实战篇2.2)

MRP的重组时间为 200ms 因此 PROFINET 通信必须选择大于 200ms 的看门狗时间,看门狗。ET200SP默认为 2ms*3=6ms) MRP 的重组时间为 200ms 故系统会报出看门狗超时。更新,默认是 3 个周期,超出设置的周期数就会报 IO 设备故障。时间不是直接配置的,而是作为没有 IO 数据可接受的更新周期,也就是允许几个周期没有数据。来达到大于 200ms 的看门狗时间的要求(看门狗时间 可接受更新周期数 更新时间)。是IO 控制器和 IO 设备)

weixin_42580591的博客 370

Java内存访问重排序的研究

什么是重排序 请先看这样一段代码1 public class PossibleReordering { static int x = 0, y = 0; static int a = 0, b = 0; public static void main(String[] args) throws InterruptedException { Thread one = new...

美团技术团队 969

RISC-V详细介绍

文章目录写在前面什么是RISC-VRISC-V诞生的背景ISA霸权摩尔定律的穷途末路穷困潦倒的学者不断增长的指令数量RISC-V架构设计思想如何设计一个好的ISARISC-V之RV32I四个典型特点RISC-V之乘除法指令指令格式用乘法代替常数除法RISC-V之RV64RISC-V的特权架构机器模式监管者模式 写在前面 本文主要基于RISC-V中文手册,其中包括但不限于一些网络的资料。本文版权属于skywf,转载或借用请联系作者。 什么是RISC-V RISC-V(发音为“risk-five”)是一个基于

skywf的博客 3万+

三、Java内存模型---重排序和顺序一致性

3.2 重排序 重排序是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段。 3.2.1 数据依赖性 如果两个操作访问同一个变量,且这两个操作中有一个为写操作,此时这两个操作之间 就存在数据依赖性。数据依赖分为下列3种类型,如表3-4所示。 上面3种情况,只要重排序两个操作的执行顺序,程序的执行结果就会被改变。 前面提到过,编译器和处理器可能会对操作做重排序。编译

岁月无痕的博客 1514

手把手入门YOLO到改进优化教程 | 【P5进阶篇】YOLOv8损失函数改进实战-损失函数IoU之KLD Loss

在本节,将从 KLD Loss(Kullback–Leibler Divergence Loss)的理论到实战代码实现,带你把 KLD Loss融合进 YOLOv8 的训练框架中。并通过训练日志与实验结果,验证 KLD Loss 在实际工程中的优势。

嵌入式阿齐Archie 2万+

LVGL(lv_canvas)

这篇文章介绍了LVGL图形库中的lv_canvas组件,主要内容包括: lv_canvas是一个绘图缓冲区对象,提供丰富的绘图API,可以理解为LVGL的"离屏画布"。 基本使用流程:创建缓冲区->创建canvas对象->设置缓存和尺寸->进行绘图操作。 详细列举了常用的绘图函数,如绘制线条、矩形、文字、图片等。 提供了示例代码展示如何创建画布并绘制一条红色线段。 介绍了canvas的典型应用场景,如动态波形绘制、自定义控件底图等。 对比了canvas与普通img的区别

m0_49476241的博客 1032

Java内存模型-重排序

Java内存模型(Java Memory Model,JMM)定义了Java程序中线程如何与主存(Main Memory)和工作内存(Working Memory)进行交互。重排序是JMM的一个重要概念,它指的是指令在执行过程中可能发生的乱序执行现象。在多线程编程中,重排序可能会导致程序行为的不可预测性和不一致性。为了保证程序的正确性,JMM规定了三种重排序规则,即处理器重排序、编译器重排序和内存重排序规则。处理器重排序规则:处理器可以对指令进行乱序执行,但是不能改变程序的数据依赖关系。

Flying_Fish_roe的博客 1062

24 SAP CPI 调用SAP HTTP接口

SAP CPI 调用SAP HTTP接口

SAP CPI 1291

java重排序_java内存模型中重排序

java内存模型中重排序在了解重排序之前我们先来了解下java多线程之间是怎样对共享数据通信的。当有多个线程对共享变量访问(读)的时候,我们要保证共享数据的统一就需要有jmm(java内存管理里模型)来进行管理。比如有一个共享变量,线程A对共享变量更改之后在线程B读到的是线程A更新的值。JMM怎么控制的呢?当有线程需要访问共享变量的时候,每个线程都会拷贝一份共享共享变量的副本到本地内存,当有线程改...

weixin_36268722的博客 188

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

Java 内存模型之重排序万字详解

摘要: 重排序是编译器和处理器为优化性能对指令执行顺序的调整,可能导致多线程程序出现不可预测的Bug。它分为编译器优化、指令级并行和内存系统重排序三类,破坏了程序的有序性和可见性,典型案例如双重检查锁定单例模式的失效。Java内存模型(JMM)通过内存屏障和happens-before规则约束重排序,开发者可利用volatile(禁止重排序、保证可见性)、synchronized(原子性与有序性)和final(安全发布)等工具规避风险。理解重排序机制是编写正确、高效并发程序的关键,推荐优先使用java.ut

油墨香^-^的博客 1029

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

java 内存模型 重排序例子

1.重排序 理解 重排序是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段 package com.pgf.pool; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; /* 作者:pgf 时间:2019年12月20日 描述:当m1 和 ...

u011042377的博客 349

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

Java内存模型(JMM)学习一、Java内存模型的抽象结构&指令重排序

Java内存模型(JMM)学习一、Java内存模型的抽象结构&指令重排序

fengxiandada的博客 435

【多线程3】java内存模型以及指令重排序理解

背景 掌握好多线程知识对java内存模型的了解也是必不可少的还有指令重排序问题。 java内存模型抽象结构 线程1将x=1写入本地内存,然后本地内存在刷入主内存; 线程2将x=1从主内存中读取出来,然后在存入本地内存。 指令重排序 重排序是值编译器和处理器为了优化程序性能而对指令序列进行冲洗排序的一种手段。 我们先看下面的代码 package com.enjoy.cap1; /** * @author: dalele * @date: 2020/11/21 19:53 * @description:

大乐乐 176

Java内存模型之重排序

在执行程序时,为了提供性能,处理器和编译器常常会对指令进行重排序,但是不能随意重排序,不是你想怎么排序就怎么排序,它需要满足以下两个条件: 在单线程环境下不能改变程序运行的结果; 存在数据依赖关系的不允许重排序 如果看过LZ上篇博客的就会知道,其实这两点可以归结于一点:无法通过happens-before原则推导出来的,JMM允许任意的排序。 as-if-serial语义 ...

我主要负责转载优秀的技术博文 179

Java 内存模型的基础(二)——重排序

一、数据依赖性 如果两个操作访问同一个变量,且两个操作中有一个为写操作,此时这两个操作就存在数据依赖性。数据依赖分为以下三种情况: 名称 代码示例 说   明 写后读 a = 1; b = 2; 写一个变量后,再读这个位置 写后写 a = 1; a = 2; 写一个变量后,再写这个变量 读后写 ...

qq_39429962的博客 362

JAVA内存模型--指令重排序

指令重排序 在执行程序时,为了提高性能,编译器和处理器会对指令做重排序。但是,JMM确保在不同的编译器和不同的处理器平台之上,通过插入特定类型的Memory Barrier来禁止特定类型的编译器重排序和处理器重排序,为上层提供一致的内存可见性保证。 编译器优化重排序:编译器在不改变单线程程序语义的前提下,可以重新安排语句的执行顺序。 指令级并行的重排序:现代处理器采用了指令级并行技术(Ins...

luoyoub的博客 353

java内存模型之重排序和顺序一致性

1 Java内存模型的基础 1.1 并发编程模型的两个关键问题 在并发编程中,需要处理两个关键问题:线程之间如何通信及线程之间如何同步(这里的线程是指并发执行的活动实体)。通信是指线程之间以何种机制来交换信息。 在命令式编程中,线程之间的通信机制有两种:共享内存和消息传递。在共享内存的并发模型里,线程之间共享程序的公共状态,通过写-读内存中的公共状态进行隐式通信。 在消息传递的并发模型里,...

striveb的博客 791

并发编程的艺术——Java内存模型(指令重排序、happens-before)

文章目录什么是 Java 内存模型Java 内存模型的组成部分JMM 与 Java 内存区域划分的区别与联系指令重排序指令重排序必须满足什么条件as-if-serial 语义数据依赖性happens-beforehappens-before规则(先行发生原则) 什么是 Java 内存模型 Java 内存模型Java Memory Model是一种抽象的概念,并不真实存在,它描述了一组规则或规范,通过这组规范定义了程序中共享变量(包括实例字段、静态字段和数组元素)的访问方式。在 Java 中,所有实例字段.

KIMTOU的博客 379

【你好面试官】010 Java内存模型之指令重排序

微信公众号:你好面试官 这里没有碎片化的知识,只有完整的知识体系。 专注于系统全面的知识点讲解,面试题目解析; 如果你觉得文章对你有帮助,欢迎关注、分享、赞赏。 ###前言 二蛋几天没有收到面试通知,以为自己已经凉凉,没想到此时再次接到了面试邀请,于是在一个风和日丽的下午,二蛋如约坐在了面试官对面,开始了今天的面试。 面试官:小伙子,咱也不用继续介绍了,你也来了几次了,这次咱就开门见山吧。 ...

不二 422

Java面试题:Java内存模型深度剖析,Java内存模型中的重排序(Reordering)现象,Java内存模型中的happens-before关系

例如,在使用synchronized块时,一个线程解锁一个对象(即退出synchronized块)的操作happens-before后续任何线程对该对象的加锁操作(即进入synchronized块),从而保证了操作的顺序性。在Java的并发编程中,内存模型扮演着至关重要的角色。通过面试题的形式,我们可以更深入地评估应聘者对Java内存模型的理解程度以及其在实际编程中的应用能力。当操作A happens-before 操作B时,操作A的结果对操作B是可见的,并且操作B不会在操作A之前发生。

杰哥在此的专栏 546

Java内存模型与指令重排序

java中的内存模型 java内存间的交互操作 lock(锁定):作用于主内存的变量,把一个变量标记为一条线程独占状态 unlock(解锁):作用于主内存的变量,把一个处于锁定状态的变量释放出来,释放后的线程可以被别的线程锁定 read(读取):作用于主内存的变量,把一个变量值从主内存传输到线程的工作内存中,以便随后的load操作使用 load(载入):作用于工作内存的变量,把read...

kangswx的博客 218
上一篇: Java 内存模型之 happens-before
下一篇: Java 内存模型之分析 volatile
god_love_hlq_xff
博客等级 码龄11年 27粉丝 37原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值