volatile的作用,线程可见,禁止指令重排序

最新推荐文章于 2023-01-18 09:24:47 发布
置顶 最新推荐文章于 2023-01-18 09:24:47 发布
阅读量232 收藏 1
点赞数
分类专栏： 编程快乐
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42687144/article/details/109683472
版权

java 多线程

volatile

第01章 volatile的作用

1.线程间可见性

说明: 一个线程对共享变量值的修改，能够及时的被其他线程看到。

2.共享变量可见性实现的原理

线程1对共享变量的修改要想被线程2及时看到，必须经过如下2个步骤：

  1. 把工作内存1中更新过的共享变量刷新到主内存中
  2. 将主内存中最新的共享变量的值更新到工作内存2中

代码演示

import java.util.concurrent.TimeUnit;

public class T01_HelloVolatile {
   /*volatile*/ boolean running= true;

    void m() {
        System.out.println("m start");
        while (running) {
        }
        System.out.println("m end!");
    }

    public static void main(String[] args) {
        T01_HelloVolatile t=new T01_HelloVolatile();
        new Thread(t::m, "t1").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.running=false;
    }
}

效果图
在这里插入图片描述加上volatile关键字后的效果图

   volatile boolean running= true;

在这里插入图片描述

注意事项:

  • 很多的执行语句有对内存进行同步的过程 例如 System.out.println("hello");在执行的过程中,内存与本地缓存做同步, 很有可能在同步过程中又得到了新的volatile的共享变量的值 (此处打印语句中使用了同步锁synchronized )

2.禁止指令重排序

带着一个问题: 美团面试题: DCL单例要不要加volatile? 问题的来源在单例中

cpu的乱序执行概念

cpu在进行读等待的同时执行命令, 是cpu乱序的根源 , 不是乱 , 而是提高效率

证明cpu是乱序的, 使用java代码证明 了解一下

public class Test02 {
    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;
        for (; ; ) {
            i++;
            x=0;y=0;
            a=0;b=0;
            Thread one=new Thread(new Runnable() {
                @Override
                public void run() {
                    //由于线程one先启动,下面这句话让它等一等线程two. 可以根据自己的电脑进行设置
                    //shortWait(1000);
                    a=1;
                    x=b;
                }
            });
            Thread other=new Thread(new Runnable() {
                @Override
                public void run() {
                    b=1;
                    y=a;
                }
            });
            one.start();other.start();
            one.join();other.join();
            String result = "第" + i + "次(" + x + "," + y + ")";
            if (x == 0 && y == 0) {
                System.err.println(result);
                break;
            }else {
                //不做处理
                /*
                * 情况分析 :
                *   1, 正常的情况下会出现 x=0,y=1
                *                      y=1,x=0;
                *                      x=1,y=1;
                * */
            }
        }
    }
}

运行结果

在这里插入图片描述
半初始化状态的概念:

Object o=new Object()有那几个执行步骤?

汇编结果展示:

0 new #2 <java/lang/Object>
3 dup
4 invokespecial #1 <java/lang/Object.<init>>
7 astore_1
8 return

半初始化状态:

  1. 对象在new 出来是默认值是null ,经过init方法后才会变成我们想要的

3.单例讲解

单例的创建方式

  1. /*
* 饿汉式
* 类加载到内存后,就实例化一个单例,jvm保证线程安全
* 简单实用,推荐使用
* 唯一缺点: 不管用到与否,类装载时就会完成实例化
* Class.forName("")
* */
public class Demo01 {
    private static final Demo01 INSTANCE = new Demo01();
    
	//构造方法私有化,不允许别人new对象
    private Demo01() {
    }
	
    //无论调用多少次getInstance方法,拿到的都是唯一的一个INSTANCE对象
    public static Demo01 getInstance() {
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        Demo01 demo01 = Demo01.getInstance();
        Demo01 demo02 = Demo01.getInstance();
        System.out.println(demo01==demo02);//true
    }
}

  2. /*
* 优化了,无论用不用都要初始化的问题
* 产生了问题:
*   虽然达到了按需初始化的目的,但却带来线程不安全的问题
* */
public class Mgr03 {
    private static Mgr03 INSTANCE;
    private Mgr03(){}

    public static Mgr03 getInstance() {
        if (INSTANCE == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()-> System.out.println(Mgr03.getInstance().hashCode())).start();
        }
    }
    //结果 1703607146 877465552 1703607146 2062736005
}

  3. /*
* 虽然达到了按需初始化的目的,但却带来线程不安全的问题
* 解决方法,加锁
* 产生了问题: 锁的粒度太粗,锁住的代码过多,效率变得很低
* */
public class Mgr04 {
    private static Mgr04 INSTANCE;
    private Mgr04(){}

    public synchronized static Mgr04 getInstance() {
        //业务逻辑,此处省略了一万行
        if (INSTANCE == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr04();
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()-> System.out.println(Mgr04.getInstance().hashCode())).start();
        }
    }
}


  4. /*
* 感觉上解决了锁的粒度问题,实际上并没有
* */
public class Mgr05 {
    private static Mgr05 INSTANCE;
    private Mgr05(){}

    public  static Mgr05 getInstance() {
        if (INSTANCE == null) {
            //第一步判断会出现线程安全问题
            synchronized (Mgr05.class){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new Mgr05();
            }
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()-> System.out.println(Mgr05.getInstance().hashCode())).start();
        }
    }
}

  5. /*
* 双重检查解决方案DCL  //此手法用户众多开源软件的项目中   ==重点掌握==
* 问题的来源 DCL单例到底要不要加volatile,
* */
public class Mgr06 {
    
    //private static Mgr06 INSTANCE;
    private volatile static Mgr06 INSTANCE;
    private Mgr06(){}

    public  static Mgr06 getInstance() {
        if (INSTANCE == null) {
            synchronized (Mgr06.class){
                if (INSTANCE==null){ //Double Check Lock
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()-> System.out.println(Mgr06.getInstance().hashCode())).start();
        }
    }
}

美团面试题: DCL单例要不要加volatile?答案: 必须加

  1. 因为程序是可以乱序执行的
  2. new 一个对象是存在半初始化状态的

存在这种可能( 该可能概率就是在大海里找到了我标记的一粒沙子 )

第一个线程进来才执行了半初始化指令

后面发生了指令重排序(cpu乱来了) 执行了astore_1指令( 建立了引用连接 ) , 使得 t 指向了 m=0 然而我的init还没有执行

第二个线程进来了判断了第一个是否==null 发现不是,它是半初始化的了

第二个线程直接没有进入synchronized代码块 , 最后拿着半初始化状态的对象跑了

图解:

在这里插入图片描述

结论

volatile修饰的变量在内存空间中 对它执行的指令不可以乱序

防止了其他线程拿到一个半初始化的对象

引发的问题

volatile在底层是怎么防止指令重排序的呢?

这就是内存屏障

jvm中的内存屏障:

​ 屏障两边的指令不可以重拍! 保证有序!

底层实现追溯到汇编指令就是Lock和addl指令

qq_42687144
关注
专栏目录
单例模式中的线程安全问题及volatile的禁止指令重排序作用
qq_34548229的博客
11-12 432
参考https://blog.csdn.net/chenchaofuck1/article/details/51702129 https://blog.csdn.net/weixin_37817685/article/details/80261549 一般的实现懒汉单例是线程不安全的，但如果在getInstance上加sync的话，锁的粒度太大（只有在new Instance时才需要加...
volatile的线程可见性和禁止指令重排序-多线程与高并发
phs999的博客
10-06 292
保证线程可见性 -MESI -缓存一致性协议 禁止指令重排序 -DCL单例 -Double Check Lock Object o=new Object(); new一个对象的三个步骤： a.开辟内存空间 b.初始化、赋值 c.将堆内存空间的地址赋给栈里的对象引用o。 验证线程可见性的程序： /** * volatile 关键字，使一个变量在多个线程间可见 * A B线程都用到一个变量，java默认是A线程中保留一份copy，这样如果B线程修改了该变量，则A线程未必...
volatile共享变量可见性、禁止指令重排
hnd978142833的博客
01-18 354
volatile 共享变量的可见性和禁止指令重排
java并发关键字：volatile深入浅出：可见性、防止指令重排
hiliang521的博客
08-01 873
volatile深入浅出：从作用、实现原理、及应用场景来分析
Volatile特性之 禁止指令重排
weixin_40230655的博客
06-07 432
计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令重排，一般分为以下三种： 源代码 -> 编译器优化的重排 -> 指令并行的重排 -> 内存系统的重排 -> 最终执行指令 单线程环境里面确保最终执行结果和代码顺序的结果一致 处理器在进行重排序时，必须要考虑指令之间的数据依赖性 多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。 指令重排 - example 1 public void mySort() { in
Java volatile 之禁止指令重排序
实践求真知
06-21 1673
一单例的演变 a饿汉式 1代码 /** * 饿汉式 * 类加载到内存后，就实例化一个单例，JVM 保证线程安全 * 简单实用，推荐使用 * 唯一缺点：不管用到与否，类装载时就完成实例化。 */ public class Mgr01 { private static final Mgr01 INSTANCE = new Mgr01(); private Mgr01() { } public static Mgr01 getInstance() { ...
volatile可见性、原子性、禁止指令重排序简介
d303577562的博客
10-10 442
在多线程并发编程中synchronized和volatile都扮演着重要的角色，volatile是轻量级的synchronized，他在多处理器开发中保证了共享变量的可见性。可见性的意思是当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。如果volatile变量修饰符使用恰当的话，它比synchronized是使用和执行成本更低，因为它不会引起线程上下文的切换和调度。 1.volaile的定义与实现原理 Java语言规范第3版中对volatile的定义如下： Java编程语言允许线程访问共享变
单例模式的双重检验锁+volatile禁止指令重排序
qq_40180366的博客
09-27 286
单例模式的双重检验锁+volatile禁止指令重排序 懒汉式，非线程安全 public class Singleton { private static Singleton instance; private Singleton (){} public static Singleton getInstance() { if (instance == null) { instance = new Singleton(); } retur
volatile如何禁止指令重排序？volatile如何保证可见性？
05-03
在C/C++中，`volatile`关键字可以防止...需要注意的是，`volatile`关键字只能保证单个变量的可见性和禁止指令重排序，对于多个变量之间的顺序关系和同步操作，需要使用其他多线程同步机制，如互斥锁、条件变量等。
java中 volatile如何禁止指令重排序？volatile如何保证可见性？
最新发布
05-03
在Java中，volatile关键字可以确保变量的可见性和禁止指令重排序。 为了禁止指令重排序，Java编译器会在生成字节码时插入内存屏障（memory barrier），即在指令执行前后添加内存屏障，防止指令重排序。这样就可以...
volatile关键字作用与内存可见性、指令重排序概述[JAVA]
程序员进阶之路
10-21 8725
在理解volotile关键字的作用之前，先粗略解释下内存可见性与指令重排序。1. 内存可见性Java内存模型规定，对于多个线程共享的变量，存储在主内存当中，每个线程都有自己独立的工作内存，并且线程只能访问自己的工作内存，不可以访问其它线程的工作内存。工作内存中保存了主内存中共享变量的副本，线程要操作这些共享变量，只能通过操作工作内存中的副本来实现，操作完毕之后再同步回到主内存当中，其JVM内存模型大
volatile的原理和实现机制 || volatile到底如何保证可见性和禁止指令重排序的？...
weixin_33909059的博客
04-20 569
为什么80%的码农都做不了架构师？>>> ...
Java volatile 关键字详解
低吟不作语的博客
10-17 887
volatile 概述 volatile 是 Java 提供的一种轻量级的同步机制。相比于传统的 synchronize，虽然 volatile 能实现的同步性要差一些，但开销更低，因为它不会引起频繁的线程上下文切换和调度。 为了更好的理解 volatile 的作用，首先要了解一下 Java 内存模型与并发编程三要素 Java 内存模型 Java 虚拟机规范中定义了 Java 内存模型（Java Memory Model，JMM），用于屏蔽各种硬件和操作系统的内存访问差异，以实现让 Java 程序.
volatile的原理和实现机制 || volatile到底如何保证可见性和禁止指令重排序的？
Peanut的博客
03-23 275
下面这段话摘自《深入理解Java虚拟机》： “观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令” lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能： 1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句...
volatile禁止指令重排序
抛弃幻想，准备斗争
11-05 1884
何为指令重排序： 计算机在执行程序时,为了提高性能,编译器和处理器常常会做指令重排,一把分为以下3种： 编译器优化的重排、指令并行的重排、内存系统的重排。 单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致。 处理器在进行重新排序是必须要考虑指令之间的数据依赖性。 多线程环境中线程交替执行,由于编译器优化重排的存在,两个线程使用的变量能否保持一致性是无法确定的,结果无法预测。 ...
双重检测加synchronized以及volatile实现单例懒汉式加载bean
qq_44682657的博客
03-25 1392
懒汉式单例模式 一、概述         懒汉式单例模式和饿汉式单例模式有着明显的区别，懒汉式单例模式是当且仅当第一次使用某个bean对象时才会创建一个bean实例对象；而饿汉式单例模式是指在类加载过程中的初始化阶段就直接创建bean实例对象。 二、懒汉式单例实现实例 代码核心部分如下： // 定义dclTest引用 private static volatile DCLTest dclTest = null;
volatile 指令重排以及为什么禁止指令重排
weixin_43982927的博客
08-14 4251
这里是引用 java指令重排以及volatile 为什么禁止指令重排指令重排序什么是指令重排序为什么要进行指令重排序如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 指令重排序 什么是指令重排序 处理器对写入的代码进行乱序执行优化， 并保证 优化后的执行 结果和正常执.
volatile保证可见性和禁止指令重排序的原理
风起尘落的博客
06-12 1552
下面这段话摘自《深入理解Java虚拟机》： 　　“观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令” 　　lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能： 　　1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成； 　　2）它会强制将对缓存的修改操作立即写入主存； 　
Java 关键字 volatile 的作用（2/2）：禁止指令重排序
XPiedPiperX的博客
12-06 393
我们先来看一段 Java 代码，DCL (Double Check Lock) 单例模式： package singleton; public class Mgr06 { private volatile static Mgr06 INSTANCE; private Mgr06() { } public static Mgr06 getInstance() { if (INSTANCE == null) { synch
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值