java是怎么禁止指令重排序的

最新推荐文章于 2024-11-07 22:08:56 发布

原创最新推荐文章于 2024-11-07 22:08:56 发布 · 1.7k 阅读

3 ·

CC 4.0 BY-SA版权

底层知识专栏收录该内容

5 篇文章

订阅专栏

一、虚拟机规范

8个 happens-before，4个内存屏障（LL LS SS SL）

as-if-serial 不管硬件什么顺序，单线程执行的结果不变，看上去像是serial

二、cpu 层面的支持

指令原语：（intel ） lfence sfence mfence(mixed fence) 原语前后的指令不能重排序

总线锁原子指令如x86上的lock...指令是一个full barrier，执行时会锁住内存子系统保证执行顺序，甚至跨多个cpu。

lock用于在多处理器中执行指令时对共享内存的独占使用。它的副作用是能够将当前处理器对应缓存的内容刷新到内存，并使其他处理器对应的缓存失效。另外还提供了有序的指令无法越过这个内存屏障的作用。

三、具体实现

software locks通常使用内存屏障或原子指令来实现变量可见性和程序执行的顺序性。

1、volatile的规范

2、hotspot volatile 实现是直接使用的总线锁汇编指令 lock addl $0x0,(%rsp)

参考：

volatile与lock前缀指令

https://www.cnblogs.com/badboys/p/12695183.html

java 中volatile和lock原理分析

https://www.jb51.net/article/109788.htm

java 8大happen-before原则超全面详解

https://www.jianshu.com/p/1508eedba54d

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

dunjian_cool

关注关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

前沿篇：西门子博图指令（指令含义）（工控PLC工程师入门必读，5天可上手调试）

weixin_42430971的博客

06-02

3万+

博图编程指令介绍在西门子PLC实际编程使用情况中，梯形图语言是PLC程序设计中最常用的编程语言。它是与继电器线路类似的一种编程语言。由于电气设计人员对继电器控制较为熟悉，因此，梯形图编程语言得到了广泛的欢迎和应用。梯形图编程语言的特点是：与电气操作原理图相对应，具有直观性和对应性；与原有继电器控制相一致，电气设计人员易于掌握。梯形图编程语言与原有的继电器控制的不同点是，梯形图中的能流不是实际意义的电流，内部的继电器也不是实际存在的继电器，应用时，需要与原有继电器控制的概念区别对待。 instructio

【Java并发编程之什么是指令重排序？如何避免指令重排序?】

极客星云-优快云博客

02-10

1425

在Java中，指令重排序是指编译器和处理器为了提高程序执行效率，可能会对指令的执行顺序进行重新排列。这种重排序不会改变单线程程序的执行结果（即遵循as-if-serial语义），但在多线程环境下，可能会导致不可预期的行为。

参与评论您还未登录，请先登录后发表或查看评论

Java volatile 之禁止指令重排序

实践求真知

06-21

1821

一单例的演变 a饿汉式 1代码 /** * 饿汉式 * 类加载到内存后，就实例化一个单例，JVM 保证线程安全 * 简单实用，推荐使用 * 唯一缺点：不管用到与否，类装载时就完成实例化。 */ public class Mgr01 { private static final Mgr01 INSTANCE = new Mgr01(); private Mgr01() { } public static Mgr01 getInstance() { ...

volatile是如何禁止指令进行重排序的

weixin_69252724的博客

04-13

689

为了保证能正确实现volatile的内存语义，JMM在采取了保守策略：在每个volatile写的后面，或者在每个volatile读的前面插入一个StoreLoad屏障。虽然StoreStore屏障主要作用于防止store-store重排序，但在volatile写操作中实际会使用更复杂的内存屏障组合，以确保volatile写之前的普通读不会被重排到volatile写之后。***第1步：***在每个volatile写操作的前面插入一个StoreStore屏障，后面插入一个StoreLoad屏障。

【Java并发编程】volatile（二）：防止指令重排序

A minor

04-14

671

在上一篇文章我们通过三个示例介绍了 volatile 能够保证多线程环境下的可见性，而 volatile关键字另一个作用就是禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象。下面看一个非常典型的禁止重排优化的例子DCL，如下： public class Singleton { private static Object lock = new Object(); private static Singleton instance = null; private Singlet

java避免指令重排

weixin_31642733的博客

07-20

258

Java避免指令重排在多线程编程中，指令重排是一个常见的问题，它可能会导致程序出现不可预测的行为。Java作为一种面向对象的编程语言，也存在这样的问题。本文将介绍Java中指令重排的概念，以及如何避免它。指令重排的概念指令重排是指编译器或处理器为了优化程序的执行效率，可能会改变代码的执行顺序。这在单线程程序中通常不会...

浅谈java指令重排序的问题

08-29

Java指令重排序是Java虚拟机（JVM）和CPU的优化机制，目的是为了提高程序的执行效率。该机制可以在虚拟机层面和硬件层面对指令进行重新排序，以充分利用CPU的资源。虚拟机层面的指令重排序是为了减少内存操作速度...

【JavaEE初阶 — 多线程】单例模式＆指令重排序问题

OuO-1 的博客

11-07

2394

【JavaEE初阶 — 多线程】单例模式＆指令重排序

Java volatile如何防止指令重排序

豪猪的博客

07-16

5221

voliate关键字的两个作用 1、保证变量的可见性：当一个被volatile关键字修饰的变量被一个线程修改的时候，其他线程可以立刻得到修改之后的结果。当一个线程向被volatile关键字修饰的变量写入数据的时候，虚拟机会强制它被值刷新到主内存中。当一个线程用到被volatile关键字修饰的值的时候，虚拟机会强制要求它从主内存中读取。 2、屏蔽指令重排序：指令重排序是编译器和处理器为了高效...

相对跳转指令和绝对跳转指令的特殊用法

05-22

当程序的编译地址与运行地址不一致时，使用相对跳转指令和绝对跳转指令就需要注意了，本文档将讲述其中原因。

java synchronized具有禁止重排序功能

SHENMEGUI_32的博客

09-15

5125

1.结论我们知道volatile关键字具有禁止指令重排序的功能，而且能保证可见性，但不能保证原子性。synchronized关键字则不仅仅能保证可见性，还能保证原子性，那么synchronized关键字是否像volatile那样具有禁止指令重排序的功能呢？答案是肯定的，synchronized具有禁止重排序功能。2.论据出处查找国内文档，发现基本对synchronized的描述很少提及禁止重排序的问

java怎么避免重排序,volatile如何避免指令重排序？原来使用了内存屏障

weixin_39637049的博客

03-10

427

在多线程的世界里，一共有三个问题：原子性问题、可见性问题、有序性问题。整个java并发体系也是围绕着如何解决这三个问题来设计的。volatile关键字也不例外，我们都知道它解决了可见性和有序性，但是不能保证原子性。这篇文章也主要基于其中一个特性，也就是研究一下volatile是如何保证有序性的。一、有序性1、有序性案例有序性指的是：程序执行的顺序按照代码的先后顺序执行。我们可以先看一个被列举了一...

java怎么避免重排序,Java volatile 怎么保证不被指令重排序优化

weixin_35782148的博客

03-10

610

内存间交互操作lock: 作用主内存unlock: 作用主内存read/load：这两个操作顺序执行,不能单独出现;主内存的变量=>工作内存的变量use: 作用工作内存,把工作内存变量传给执行引擎assign: 作用工作内存,把执行引擎收到的值赋给工作内存变量store/write: 这两个操作顺序执行;不能单独出现;工作内存的变量=>主内存的变量通过主内存与工作内存交互来理解这些操作...

weixin_32601937的博客

03-02

130

也学了很久 java 了，但对重排序那块还是不太理解。直接上代码吧public class App {private static boolean flag = false;private static int cnt = 0;public static void main(String[] argv) throws Exception{new Thread(() -> {while (!f...

volatile 指令重排以及为什么禁止指令重排

weixin_43982927的博客

08-14

5110

这里是引用 java指令重排以及volatile 为什么禁止指令重排指令重排序什么是指令重排序为什么要进行指令重排序如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入指令重排序 什么是指令重排序 处理器对写入的代码进行乱序执行优化，并保证优化后的执行结果和正常执.

Java内存中指令重排序导致的线程问题，以及 volatile 作用之禁止内存指令重排序的代码实例

请叫我大师兄

06-12

1156

一般在看JMM(Java内存模型)的时候，里面有代码会因为种种原因优化，导致指令重排。也没实际见过。也没法验证这个说法。说是volatile这个关键词可以1，禁止指令重排，2，内存可见。这都是理论，回头就忘记了。下面用实际例子，切身体会一下他这个重排序。这个Java代码例子充分的见识了指令重排序对多线程的影响，同时也是实际Java代码例子说明volatile可以禁止指令重排序，对多线程开发的作用也不小。

Java指令屏障_【Java】指令重排序、内存屏障很难？看完这篇你就懂了！

weixin_39541681的博客

03-01

320

面试官在问到多线程编程的时候，指令重排序、内存屏障经常会被提起。如果你对这两者有一定的理解，那这就是你的加分项。(一)什么是指令重排序为了使处理器内部的运算单元能尽量被充分利用，处理器可能会对输入的代码进行乱序执行优化，处理器会在计算之后将乱序执行的结果重组，并确保这一结果和顺序执行结果是一致的，但是这个过程并不保证各个语句计算的先后顺序和输入代码中的顺序一致。这就是指令重排序。简单来说，就是指你...

003 Java并发编程之volatile的内存语义及内存语义的实现（内存屏障来禁止指令重排序）

专注于后端开发，时常接触大数据、人工智能等

03-03

333

1、JMM通过控制主内存与每个线程的本地内存之间的交互，为Java程序员提供内存可见性保证 1.1 线程间的通信和同步是并发编程的2大问题：（1）线程之间的通信机制有两种：共享内存和消息传递。Java并发中线程之间的通信采用的是共享内存模型。（2）同步是指程序中用于控制不同线程间操作发生相对顺序的机制。 1.2 Java线程之间的通信由Java内存模型（简称为JMM）控制，JMM决定一个线程对共享变量的写入何时对另一个线程可见。从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：线程之间的

java中什么是指令重排序

最新发布

08-06

<think>我们正在讨论Java中的指令重排序问题。根据引用内容，指令重排序是编译器和处理器为了优化性能而对指令执行顺序进行重新排序的过程。在单线程环境中，这种重排序不会影响程序的正确性，因为编译器和处理器会保证程序的执行结果与代码逻辑顺序一致。但在多线程环境中，指令重排序可能导致意想不到的结果，因为不同线程之间的操作顺序可能被打乱。接下来，我将详细解释指令重排序的定义、原因以及它对并发程序的影响，并参考提供的引用内容进行说明。 ### 1. 指令重排序的定义指令重排序是指编译器和处理器在不改变程序语义的前提下，重新安排指令的执行顺序以优化性能。重排序主要发生在两个层面： - **编译器重排序**：编译器在生成字节码或机器码时调整指令顺序。 - **处理器重排序**：处理器在执行指令时，可能改变指令的执行顺序（如乱序执行）。在单线程程序中，重排序不会影响程序的最终结果，因为编译器和处理器会遵守**数据依赖性**原则：如果两条指令存在数据依赖关系（如一条指令的输出是另一条指令的输入），则不会对它们重排序。例如： ```java int a = 1; // 语句1 int b = a + 1; // 语句2 ``` 语句2依赖于语句1的结果，因此不会被重排序到语句1之前[^1]。 ### 2. 指令重排序的原因 重排序的主要目的是提高性能： - **充分利用CPU流水线**：避免指令等待（如等待内存加载数据），让后续独立指令提前执行。 - **减少内存访问延迟**：通过重排序将内存访问操作集中执行，减少缓存未命中的影响。 ### 3. 指令重排序对并发程序的影响在多线程环境中，指令重排序可能导致**内存可见性问题**和**程序逻辑错误**。因为不同线程可能观察到其他线程操作的重排序版本。例如： ```java // 引用[3]中的示例 public class VolatileExample { private volatile boolean flag = false; private int number = 0; public void writer() { number = 42; // 语句1 flag = true; // 语句2 } public void reader() { if (flag) { // 语句3 System.out.println(number); // 语句4 } } } ``` - 如果没有重排序，当线程B执行`reader()`看到`flag==true`时，`number`一定已被赋值为42。 - 但如果发生重排序，`writer()`中的语句1和语句2可能被重排序（因为两者无数据依赖）。此时线程B可能在`number`赋值前看到`flag=true`，导致打印出0。 ### 4. 如何避免指令重排序的问题 Java提供以下机制防止重排序导致的问题： - **`volatile`关键字**：禁止对`volatile`变量的读写操作与其前后的普通变量读写重排序（内存屏障效果）[^2][^3]。 - **`synchronized`关键字**：通过互斥锁保证临界区内指令不会被重排序到临界区外。 - **`final`关键字**：保证构造函数中对`final`字段的赋值不会被重排序到构造函数之外。 ### 5. 内存屏障（Memory Barrier）内存屏障是一种CPU指令，用于禁止特定类型的重排序： - **写屏障（Store Barrier）**：确保屏障前的所有写操作对其他线程可见。 - **读屏障（Load Barrier）**：确保屏障后的读操作能获取最新数据。在Java中，`volatile`变量的读写会自动插入内存屏障[^2]。 ### 总结 - **指令重排序**是性能优化手段，但在多线程中可能破坏程序正确性。 - **数据依赖性**是单线程中重排序的约束条件。 - **并发控制**需使用`volatile`、`synchronized`等机制防止重排序问题。 §§相关问题§§ 1. Java内存模型（JMM）如何规范指令重排序？ 2. 除了`volatile`，还有哪些方法可以保证多线程环境下的内存可见性？ 3. 如何通过代码演示指令重排序导致的问题？ 4. Happens-Before原则与指令重排序的关系是什么？[^3]</think>### Java中的指令重排序：定义与并发影响 #### 1. **指令重排序的定义** 指令重排序是编译器和处理器为了提高程序执行效率，在**不改变单线程程序语义**的前提下，对指令执行顺序进行重新排列的优化技术。主要包括两种类型： - **编译器重排序**：在编译字节码阶段调整指令顺序 - **处理器重排序**：CPU执行时并行执行无依赖的指令（乱序执行）例如以下代码： ```java int a = 1; // 语句1 int b = 2; // 语句2 int c = a + b; // 语句3 ``` 编译器和处理器可能将语句1和2的顺序互换，因为两者无数据依赖关系，但不影响语句3的结果[^1]。 #### 2. **重排序的触发条件** 重排序仅在满足**数据依赖性规则**时被禁止： - **写后读**：`a=1; b=a;`（不可重排序） - **写后写**：`a=1; a=2;`（不可重排序） - **读后写**：`b=a; a=1;`（不可重排序）无这些依赖关系的指令可能被重排序[^1]。 #### 3. **对并发程序的影响** 在多线程环境中，重排序会导致**内存可见性问题**和**程序逻辑错误**： **典型问题示例**： ```java // 引用[3]的示例 public class ReorderingDemo { private int x = 0; private boolean ready = false; // 非volatile // 线程A执行 public void writer() { x = 42; // 语句1 ready = true; // 语句2 可能被重排到语句1前 } // 线程B执行 public void reader() { if (ready) { // 语句3 System.out.println(x); // 可能输出0（未初始化值） } } } ``` 可能发生的时间序列： 1. 线程B执行语句3（`ready=true`） 2. 线程A重排序后先执行语句2 3. 线程B输出`x=0` 4. 线程A执行语句1（`x=42`） #### 4. **解决方案：内存屏障** 通过内存屏障禁止特定类型的重排序： ```java private volatile boolean ready = false; // 添加volatile ``` `volatile`的作用： 1. 禁止重排序：确保`x=42`始终在`ready=true`**之前**执行 2. 保证可见性：修改立即对其他线程可见 3. 插入内存屏障：生成`LoadStore`+`StoreStore`屏障[^2] #### 5. **Happens-Before规则** Java内存模型通过Happens-Before规则解决重排序问题： - **volatile规则**：对volatile变量的写操作先于后续读操作 - **监视器锁规则**：解锁操作先于后续加锁操作 - **传递性规则**：若A先于B，B先于C，则A先于C 在引用[3]的示例中： ```java public void writer() { number = 42; // 普通写 flag = true; // volatile写 → 建立内存屏障 } public void reader() { if (flag) { // volatile读 → 建立内存屏障 System.out.println(number); // 保证看到42 } } ``` `volatile`写操作前的所有操作（`number=42`）对后续`volatile`读操作可见[^3]。 ### 总结 | 特性 | 单线程环境 | 多线程环境 | |------|------------|------------| | **重排序允许性** | ✅ 安全 | ❌ 危险 | | **数据依赖性** | 自动保持 | 可能被破坏 | | **解决方案** | 无需处理 | volatile/synchronized | | **关键机制** | - | 内存屏障 + Happens-Before | > 指令重排序是提升性能的重要手段，但在并发编程中必须通过`volatile`、`synchronized`或`final`等机制约束其行为，避免出现不可预测的结果[^1][^2][^3]。