Java内存模型之重排序

这篇具有很好参考价值的文章主要介绍了Java内存模型之重排序。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1.什么是重排序

首先来看一个代码案例,尝试分析一下 x 和 y 的运行结果。

import java.util.concurrent.CountDownLatch;

/**
 * 演示重排序的现象,直到达到某个条件才停止,测试小概率事件
 */
public class OutOfOrderExecution {

    private static int x = 0, y = 0;
    private static int a = 0, b = 0;

    public static void main(String[] args) throws InterruptedException {
        int i = 0;

        while (true) {
            i++;
            x = 0;
            y = 0;
            a = 0;
            b = 0;

            CountDownLatch latch = new CountDownLatch(3);

            Thread one = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        latch.countDown();
                        latch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    a = 1;
                    x = b;
                }
            });

            Thread two = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        latch.countDown();
                        latch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    b = 1;
                    y = a;
                }
            });

            two.start();
            one.start();
            latch.countDown();
            one.join();
            two.join();

            String result = "第" + i + "次 (x = " + x + ", y = " + y + ")";
            if (x == 0 && y == 0) {
                System.out.println(result);
                break;
            } else {
                System.out.println(result);
            }
        }
    }
}

经过分析可知,线程 one 的第 33 行和第 34 行和线程 two 的第 47 行和第 48 行是核心代码,这 4 行代码的执行顺序决定了最终 x 和 y 的结果。

根据大多数人对多线程的认知,在线程 one 内部,第 33 行和第 34 行代码的执行顺序是不会改变的,即 a=1 会在 x=b 前执行;在线程 two 内部,第 47 行和第 48 行代码的执行顺序是不会改变的,即 b=1 会在 y=a 前执行。在此前提下,x 和 y 的最终结果一共有 3 种情况:

  • 最终结果是 x=0, y=1,可能的执行顺序是 a=1; x=b; b=1; y=a;
  • 最终结果是 x=1, y=0,可能的执行顺序是 b=1; y=a; a=1; x=b;
  • 最终结果是 x=1, y=1,可能的执行顺序是 b=1; a=1; x=b; y=a;

然而,在实际运行过程中,会出现 x=0, y=0 的结果,这是因为重排序发生了,其中一种可能的代码执行顺序是 y=a; a=1; x=b; b=1;

Java内存模型之重排序,Java,java,jmm,重排序

至此,便可解答一个问题:什么是重排序?

在线程内部的两行代码的实际执行顺序和代码在Java文件中的顺序不一致,代码指令并不是严格按照代码语句顺序执行的,它们的顺序被改变了,这就是重排序。

2.重排序的好处

对比下面重排序前后的指令优化,我们可以发现,重排序的好处是可以提高处理速度。

Java内存模型之重排序,Java,java,jmm,重排序

Java内存模型之重排序,Java,java,jmm,重排序

3.重排序的三种情况

  • 编译器优化:包括JVM,JIT编译器等。
  • CPU指令重排:就算编译器不发生重排,CPU也可能对指令进行重排。
  • 内存的“重排序”:线程 A 的修改线程 B 却看不到,引出可见性问题。

4.用volatile修正重排序问题

使用 volatile 关键字修正上面的 OutOfOrderExecution 类,加了 volatile 后,就不会出现 (x=0, y=0) 的情况了。文章来源地址https://www.toymoban.com/news/detail-787751.html

import java.util.concurrent.CountDownLatch;

/**
 * 使用volatile关键字修正重排序问题
 */
public class OutOfOrderExecution {

    private volatile static int x = 0, y = 0;
    private volatile static int a = 0, b = 0;

    public static void main(String[] args) throws InterruptedException {
        int i = 0;

        while (true) {
            i++;
            x = 0;
            y = 0;
            a = 0;
            b = 0;

            CountDownLatch latch = new CountDownLatch(3);

            Thread one = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        latch.countDown();
                        latch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    a = 1;
                    x = b;
                }
            });

            Thread two = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        latch.countDown();
                        latch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    b = 1;
                    y = a;
                }
            });

            two.start();
            one.start();
            latch.countDown();
            one.join();
            two.join();

            String result = "第" + i + "次 (x = " + x + ", y = " + y + ")";
            if (x == 0 && y == 0) {
                System.out.println(result);
                break;
            } else {
                System.out.println(result);
            }
        }
    }
}

到了这里,关于Java内存模型之重排序的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java 内存模型(JMM)探寻原理,深度讲解

    目录 一. 前言 二. 为什么会有内存模型 2.1. 硬件内存架构 2.2. 缓存一致性问题 2.3. 处理器优化和指令重排序 三. 并发编程的问题 四. Java 内存模型(JMM) 4.1. Java 运行时内存区域与硬件内存的关系 4.2. Java 线程与主内存的关系 4.3. 线程间通信 五. 主内存和工作内存 六. J

    2024年04月22日
    浏览(35)
  • Java内存模型(JMM)和volatile原理

    目录 一、Java 内存模型 二、可见性 三、有序性 四、volatile原理  1、可见性保证 2、有序性保证 五、线程安全的单例 JMM即Java Memory Model,他定义了 主存(共享的数据) 、 工作内存(私有的数据) 抽象概念,底层对应着CPU寄存器、缓存、硬件内存、CPU指令优化等 JMM体现以下

    2024年02月09日
    浏览(43)
  • Java内存区域(运行时数据区域)和内存模型(JMM)

    Java 内存区域和内存模型是不一样的东西,内存区域是指 Jvm 运行时将数据分区域存储,强调对内存空间的划分。 而内存模型(Java Memory Model,简称 JMM )是定义了线程和主内存之间的抽象关系,即 JMM 定义了 JVM 在计算机内存(RAM)中的工作方式,如果我们要想深入了解Java并发

    2024年02月12日
    浏览(46)
  • Java内存模型之重排序

    首先来看一个代码案例,尝试分析一下 x 和 y 的运行结果。 经过分析可知,线程 one 的第 33 行和第 34 行和线程 two 的第 47 行和第 48 行是核心代码,这 4 行代码的执行顺序决定了最终 x 和 y 的结果。 根据大多数人对多线程的认知,在线程 one 内部,第 33 行和第 34 行代码的执

    2024年02月02日
    浏览(21)
  • 区分什么是Java内存模型(JMM)和 JVM运行时数据区

    Java的内存区域和内存模型是不一样的东西,内存区域是指 JVM 运行时将数据分区域存储,强调对内存空间的划分 。 而内存模型(Java Memory Model,简称 JMM )是 定义了线程和主内存之间的抽象关系,即 JMM 定义了 JVM 在计算机内存(RAM)中的工作方式 ,如果我们要想深入了解Java并

    2024年02月11日
    浏览(49)
  • 【javaEE面试题(五)在JMM(Java Memory Model (Java 内存模型))下谈volatile的作用】

    volatile 能保证内存可见性 volatile 修饰的变量, 能够保证 “内存可见性”. 代码在写入 volatile 修饰的变量的时候 改变线程工作内存中volatile变量副本的值 将改变后的副本的值从工作内存 刷新到主内存 代码在读取 volatile 修饰的变量的时候 从主内存中读取volatile变量的最新值到

    2024年02月13日
    浏览(45)
  • 【javaEE面试题(五)在JMM(Java Memory Model (Java 内存模型))下谈volatile的作用】【保证内存可见 和 指令有序】

    volatile 能保证内存可见性 volatile 修饰的变量, 能够保证 “内存可见性”. 代码在写入 volatile 修饰的变量的时候 改变线程工作内存中volatile变量副本的值 将改变后的副本的值从工作内存 刷新到主内存 代码在读取 volatile 修饰的变量的时候 从主内存中读取volatile变量的最新值到

    2024年02月16日
    浏览(37)
  • 并发编程之三大特性及JMM内存模型

    目录 原子性 如何保证原子性 可见性 如何保证可见性 有序性 如何保证有序性 Java内存模型(JMM内存模型) Java内存模型的一些关键概念: 主内存与工作内存交互协议 Java内存模型通过以下手段来确保多线程程序的正确性: 锁机制 volatile volatile禁止指令重排序  Happens-Before 并发三

    2024年01月19日
    浏览(42)
  • 【JUC系列-01】深入理解JMM内存模型的底层实现原理

    JUC系列整体栏目 内容 链接地址 【一】深入理解JMM内存模型的底层实现原理 https://zhenghuisheng.blog.csdn.net/article/details/132400429 【二】深入理解CAS底层原理和基本使用 https://blog.csdn.net/zhenghuishengq/article/details/132478786 【三】熟练掌握Atomic原子系列基本使用 https://blog.csdn.net/zhenghuis

    2024年02月12日
    浏览(45)
  • Java 内存模型深度解析

    优质博文:IT-BLOG-CN 【1】并发中常见的两个问题: 线程之间如何通信及线程之间如何同步 。通信是指线程之间以何种机制来交换信息。在命令式编程中,线程之间的通信机制有两种: 内存共享和消息传递 ; 【2】在共享内存的并发模型里,线程之间共享程序的公共状态,通

    2024年01月21日
    浏览(33)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包