第六章volatile详解

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

volatile修饰的变量有2大特点

可以保证

  • 可见性
  • 有序性

为什么能实现这些功能,其底层原理就是内存屏障

volatile的内存语义

volatile关键字可以保证共享变量可见性,相较于普通的共享变量,使用volatile关键字可以保证共享变量的可见性

  • 当线程读取的是volatile关键字时,JMM会把该线程对应的工作内存设置为无效,线程直接从主内存中读取该值到工作内存中
    • yield和sleep会导致线程让出CPU,当线程再次调度回CPU,有可能会重新读主存(JVM规范明确表示,yield和sleep方法不一定会强行刷新工作内存,读取主存,但是volatile会强行刷新内存)
  • 当线程写的是volatile关键字变量,将当前修改后的变量值(工作内存中)立即刷新到主内存,且其他正在读此变量的线程会等待(不是阻塞),直到写回主内存操作完成,保证读的一定是刷新后的主内存值

一句话,volatile修饰的变量在某个工作内存修改后立刻会刷新会主内存,并把其他工作内存的该变量设置为无效。

内存屏障

回忆volatile的作用

  • 可见性

    • 立即刷新回主内存+失效处理。
  • 有序性

    • 禁止指令重排:存在数据依赖关系的禁止重排。

是什么

  • 内存屏障(也称内存栅栏,内存栅障,屏障指令等,是一类同步屏障指令,是CPU或编译器在对内存随机访问的操作中的一个同步点,使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作),避免代码重排序

  • 内存屏障其实就是一种JVM指令,Java内存模型的重排规则会要求Java编译器在生成JVM指令时插入特定的内存屏障指令 ,通过这些内存屏障指令,volatile实现了Java内存模型中的可见性和有序性,但volatile无法保证原子性 。

    • 内存屏障之前的所有写操作都要回写到主内存,

    • 内存屏障之后的所有读操作都能获得内存屏障之前的所有写操作的最新结果(实现了可见性)。

    • 一句话:对一个 volatile 域的写, happens-before 于任意后续对这个 volatile 域的读,也叫写后读。

内存屏障分类

  • 上一章讲解过happens-before先行发生原则,类似接口规范,落地?
  • 落地靠什么?你凭什么可以保证?你管用吗?

粗分两种

写屏障(Store Memory Barrier) :告诉处理器在写屏障之前将所有存储在缓存(store bufferes) 中的数据同步到主内存。也就是说当看到Store屏障指令, 就必须把该指令之前所有写入指令执行完毕才能继续往下执行。

读屏障(Load Memory Barrier) :处理器在读屏障之后的读操作, 都在读屏障之后执行。也就是说在Load屏障指令之后就能够保证后面的读取数据指令一定能够读取到最新的数据。

细分四种

第六章volatile详解

什么叫保证有序性

  • 禁止指令重排
    • 通过内存屏障禁止重排
  1. 重排序有可能影响程序的执行和实现, 因此, 我们有时候希望告诉JVM你别“自作聪明”给我重排序, 我这里不需要排序, 听主人的。

  2. 对于编译器的重排序, JMM会根据重排序的规则, 禁止特定类型的编译器重排序。

  3. 对于处理器的重排序, Java编译器在生成指令序列的适当位置, 插入内存屏障指令, 来禁止特定类型的处理器排序。

volatile 的底层实现原理是内存屏障,Memory Barrier(Memory Fence)

  • 对 volatile 变量的写指令后会加入写屏障
    • 写屏障会确保指令重排序时,不会将写屏障之前的代码排在写屏障之后
  • 对 volatile 变量的读指令前会加入读屏障
    • 读屏障会确保指令重排序时,不会将读屏障之后的代码排在读屏障之前

写屏障(Store Memory Barrier) :告诉处理器在写屏障之前将所有存储在缓存(store bufferes) 中的数据同步到主内存。也就是说当看到Store屏障指令, 就必须把该指令之前所有写入指令执行完毕才能继续往下执行。

读屏障(Load Memory Barrier) :处理器在读屏障之后的读操作, 都在读屏障之后执行。也就是说在Load屏障指令之后就能够保证后面的读取数据指令一定能够读取到最新的数据。

happens-before之volatile变量规则

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

第六章volatile详解

这里暂时先有个印象着就行

  • 当第一个操作为volatile读时,不论第二个操作是什么,都不能重排序。这个操作保证了volatile读之后的操作不会被重排到volatile读之前

  • 当第二个操作为volatile写时,不论第一个操作是什么,都不能重排序。这个操作保证了volatile写之前的操作不会被重排到volatile写之后

  • 当第一个操作为volatile写时,第二个操作为volatile读时,不能重排。

JMM就将内存屏障插入策略分为4种规则

读屏障

  • 在每个volatile读操作的后面插入一个LoadLoad屏障
  • 在每个volatile读操作的后面插入一个LoadStore屏障

写屏障

  • 在每个volatile写操作的前面插入一个StoreStore屏障

  • 在每个volatile写操作的后面插入一个StoreLoad屏障

第六章volatile详解

volatile特性

如何保证可见性

volatile 的底层实现原理是内存屏障,Memory Barrier(Memory Fence)

  • 对 volatile 变量的写指令后会加入写屏障
    • 保证在该屏障之前的,对共享变量的改动,都同步到主存当中
  • 对 volatile 变量的读指令前会加入读屏障
    • 保证在该屏障之后,对共享变量的读取,加载的是主存中最新数据

写屏障(Store Memory Barrier) :告诉处理器在写屏障之前将所有存储在缓存(store bufferes) 中的数据同步到主内存。也就是说当看到Store屏障指令, 就必须把该指令之前所有写入指令执行完毕才能继续往下执行。

读屏障(Load Memory Barrier) :处理器在读屏障之后的读操作, 都在读屏障之后执行。也就是说在Load屏障指令之后就能够保证后面的读取数据指令一定能够读取到最新的数据。

说明

  • 保证不同线程对某个变量完成操作后结果及时可见,即该共享变量一旦改变所有线程立即可见。

例子

public class VolatileTest1 {
//    static boolean flag = true;//不加volatile,没有可见性
    static volatile boolean flag = true;//加volatile,有可见性
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t come in");
            while (flag){//默认flag是true,如果未被修改就一直循环,下面那句话也打不出来

            }
            System.out.println(Thread.currentThread().getName()+"\t flag被修改为false,退出.....");

        },"t1").start();
        //暂停几秒
        TimeUnit.SECONDS.sleep(2);
        flag=false;
        System.out.println("main线程修改完成");
    }
}
//没有volatile时
//t1   come in
//main线程修改完成
//--------程序一直在跑(在循环里)

//有volatile时
//t1   come in
//main线程修改完成
//t1   flag被修改为false,退出.....

上述代码原理解释

  • 线程t1中为何看不到被主线程main修改为false的flag的值?

问题可能:

  • 主线程修改了flag之后没有将其刷新到主内存,所以t1线程看不到。

  • 主线程将flag刷新到了主内存,但是t1一直读取的是自己工作内存中flag的值,没有去主内存中更新获取flag最新的值。

我们的诉求:

  • 线程中修改了工作内存中的副本之后,立即将其刷新到主内存;
  • 工作内存中每次读取共享变量时,都去主内存中重新读取,然后拷贝到工作内存。

解决:

  • 使用volatile修饰共享变量,就可以达到上面的效果,被volatile修改的变量有以下特点:

    • 线程中读取的时候,每次读取都会去主内存中读取共享变量最新的值 ,然后将其复制到工作内存
    • 线程中修改了工作内存中变量的副本,修改之后会立即刷新到主内存

volatile变量的读写过程

Java内存模型定义了8种每个线程工作内存与物理主内存之间的原子操作

  • read(读取)→load(加载)→use(使用)→assign(赋值)→store(存储)→write(写入)→lock(锁定)→unlock(解锁)
  • read: 作用于主内存,将变量的值从主内存传输到工作内存,主内存到工作内存
  • load: 作用于工作内存,将read从主内存传输的变量值放入工作内存变量副本中,即数据加载
  • use: 作用于工作内存,将工作内存变量副本的值传递给执行引擎,每当JVM遇到需要该变量的字节码指令时会执行该操作
  • assign: 作用于工作内存,将从执行引擎接收到的值赋值给工作内存变量,每当JVM遇到一个给变量赋值字节码指令时会执行该操作
  • store: 作用于工作内存,将赋值完毕的工作变量的值写回给主内存
  • write: 作用于主内存,将store传输过来的变量值赋值给主内存中的变量

由于上述6条只能保证单条指令的原子性,针对多条指令的组合性原子保证,没有大面积加锁,所以,JVM提供了另外两个原子指令:

  • lock: 作用于主内存,将一个变量标记为一个线程独占的状态,只是写时候加锁,就只是锁了写变量的过程。
  • unlock: 作用于主内存,把一个处于锁定状态的变量释放,然后才能被其他线程占用

其中最核心的操作是在于我们的write操作,当我们从工作内存写到主内存的时候,会进行lock加锁操作,加锁后会清空其他线程工作内存变量的值,如果其他线程要使用该变量前必须重写从主内存加载值,当write完毕后,进行unlock进行解锁 ,这样就保证了可见性

  • 这里的锁只是锁了些变量的过程,也就是只有写完之后,其他线程才能到主内存去读数据

为何没有原子性

  • volatile变量的复合操作不具有原子性,比如number++

例子

  • synchronizedvolatile代码演示
class MyNumber{
    //volatile int num=0;
    int num=0;
    public synchronized void add(){
        num++;
    }
}
public class VolatileNoAtomicDemo {
    public static void main(String[] args) {
        MyNumber myNumber = new MyNumber();
        for (int i = 0; i <10; i++) {
            new Thread(()->{
                for (int j = 0; j < 100; j++) {
                    myNumber.add();
                }
            }).start();
        }
        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println(Thread.currentThread().getName() + "\t" + myNumber.num);

    }

}
//-------------volatile情况下
//main  941
//-----------synchronized请款下
//main  1000

读取赋值一个普通变量的情况

当线程1对主内存对象发起read操作到write操作第一套流程的时间里,线程2随时都有可能对这个主内存对象发起第二套操作

  • 当线程1开始了volatile的读写流程的时候,线程2可以在其任何时候的流程的时候进行发起read操作,因为我们的volatile的锁只是锁了在wirte的写流程

不保证原子性

  • 从底层来说,i++或者number++(在执行引擎操作时)其实是分了三步的:数据加载数据计算数据赋值 。而这三步非原子操作

第六章volatile详解

  • 对于volatile变量具备可见性 ,JVM只是保证从主内存加载到线程工作内存的值是最新的,也仅是数据加载时是最新的
  • 但是多线程环境下,“数据计算”和“数据赋值”操作可能多次出现,若数据在加载之后,若主内存volatile修饰变量发生修改之后,线程工作内存中的操作将会作废去读主内存最新值,操作出现写丢失问题。即各线程私有内存和主内存公共内存中变量不同步 ,进而导致数据不一致。由此可见volatile解决的是变量读取时的可见性问题,但无法保证原子性,对于多线程修改主内存共享变量的场景必须使用加锁同步。
  • 就比如这个i++操作,当你从主内存加载了5进入,并且加载进了工作内存,正当要进行++操作的时候,线程2进行了读取操作,也是从主内存读取了5,因为线程1没有进行write操作,所有主内存还是最新的值,符合volatile的特性,然后线程进行了8个一套操作,然后变成6写入主内存,线程1的5就失效了,就需要进行重新从内存读取到6,但是这次++操作是丢失了,所有还是线程不安全的

结论

  • volatile不适合参与到依赖当前值的运算,如i=i+1,i++之类的
  • 那么依靠可见性的特点volatile可以用在哪些地方呢?通常volatile用作保存某个状态的boolean值或or int值。 (一旦布尔值被改变迅速被看到,就可以做其他操作)

禁止指令重排

  • 重排序是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段,有时候会改变程序语句的先后顺序

  • 不存在数据依赖关系,可以重排序;

  • 存在数据依赖关系 ,禁止重排序

    • 数据依赖性 :若两个操作访问同一变量,且这两个操作中有一个为写操作,此时两操作间就存在数据依赖性。

但重排后的指令绝对不能改变原有的串行语义!这点在并发设计中必须要重点考虑!

数据依赖的实例

第六章volatile详解

  • 不存在数据依赖关系,可以重排序 ===> 重排序OK 。
  • 存在数据依赖关系,禁止重排序===> 重排序发生,会导致程序运行结果不同。
  • 编译器和处理器在重排序时,会遵守数据依赖性,不会改变存在依赖关系的两个操作的执行,但不同处理器和不同线程之间的数据性不会被编译器和处理器考虑,其只会作用于单处理器和单线程环境

如何正确使用volatile(实际工作)

单一赋值可以,但是含有符合运算赋值不可以(比如i++)

  • 下面这两个单一赋值可以的

    • volatile int a = 10;

    • volatile boolean flag = false

状态标志,判断业务是否结束

//这个前面讲过
public class UseVolatileDemo{
    private volatile static boolean flag = true;

    public static void main(String[] args){
        new Thread(() -> {
            while(flag) {
                //do something......循环
            }
        },"t1").start();

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(2L); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            flag = false;
        },"t2").start();
    }
}


开销较低的读,写锁策略

当读远多于写

  • 最土的方法就是加两个synchronized,但是读用volatile,写用synchronized可以提高性能
public class UseVolatileDemo{
    //
   // 使用:当读远多于写,结合使用内部锁和 volatile 变量来减少同步的开销
   // 理由:利用volatile保证读取操作的可见性;利用synchronized保证复合操作的原子性
     
    public class Counter {
        private volatile int value;

        public int getValue(){
            return value;   //利用volatile保证读取操作的可见性
         }
        public synchronized int increment(){
            return value++; //利用synchronized保证复合操作的原子性
        }
    }
}

单例模式双重锁案例

public class SafeDoubleCheckSingleton
{
    private static SafeDoubleCheckSingleton singleton; //-----这里没加volatile
    //私有化构造方法
    private SafeDoubleCheckSingleton(){
    }
    //双重锁设计
    public static SafeDoubleCheckSingleton getInstance(){
        if (singleton == null){
            //1.多线程并发创建对象时,会通过加锁保证只有一个线程能创建对象
            synchronized (SafeDoubleCheckSingleton.class){
                if (singleton == null){
                    //隐患:多线程环境下,由于重排序,该对象可能还未完成初始化就被其他线程读取
                    singleton = new SafeDoubleCheckSingleton();
                    //实例化分为三步
                    //1.分配对象的内存空间
                    //2.初始化对象
                    //3.设置对象指向分配的内存地址
                }
            }
        }
        //2.对象创建完毕,执行getInstance()将不需要获取锁,直接返回创建对象
        return singleton;
    }
}

单线程情况下

  • 单线程环境下(或者说正常情况下),在"问题代码处",会执行如下操作,保证能获取到已完成初始化的实例
//三步
memory = allocate(); //1.分配对象的内存空间
ctorInstance(memory); //2.初始化对象
instance = memory; //3.设置对象指向分配的内存地址

多线程情况下(由于指令重排序)
隐患:多线程环境下,在"问题代码处",会执行如下操作,由于重排序导致2,3乱序,后果就是其他线程得到的是null而不是完成初始化的对象 。(没初始化完的就是null)

正常情况

//三步
memory = allocate(); //1.分配对象的内存空间
ctorInstance(memory); //2.初始化对象
instance = memory; //3.设置对象指向分配的内存地址

非正常情况

//三步
memory = allocate(); //1.分配对象的内存空间
instance = memory; //3.设置对象指向分配的内存地址---这里指令重排了,但是对象还没有初始化
ctorInstance(memory); //2.初始化对象

解决

  • 加volatile修饰
public class SafeDoubleCheckSingleton
{
    //通过volatile声明,实现线程安全的延迟初始化。
    private volatile static SafeDoubleCheckSingleton singleton;
    //私有化构造方法
    private SafeDoubleCheckSingleton(){
    }
    //双重锁设计
    public static SafeDoubleCheckSingleton getInstance(){
        if (singleton == null){
            //1.多线程并发创建对象时,会通过加锁保证只有一个线程能创建对象
            synchronized (SafeDoubleCheckSingleton.class){
                if (singleton == null){
                    //隐患:多线程环境下,由于重排序,该对象可能还未完成初始化就被其他线程读取
                                      //原理:利用volatile,禁止 "初始化对象"(2) 和 "设置singleton指向内存空间"(3) 的重排序
                    singleton = new SafeDoubleCheckSingleton();
                }
            }
        }
        //2.对象创建完毕,执行getInstance()将不需要获取锁,直接返回创建对象
        return singleton;
    }
}


实例化singleton分多步执行(分配内存空间、初始化对象、将对象指向分配的内存空间),某些编译器为了性能原因,会将第二步和第三步进行重排序(java分配内存空间、将对象指向分配的内存空间、初始化对象)。这样,某个线程可能会获得一个未完全初始化的实例。

面试回答

valatile可见性

  • 写操作的话,这个变量的最新值会立即刷新到主内存中
  • 读操作的话,总是能够读取这个变量的最新值,也就是这个变量最后被修改的值
  • 某个线程收到通知,去读取volatile修饰的变量的值的时候,线程私有工作内存的数据失效,需要重新回到主内存区读取最新的数据

内存屏障是什么?

内存屏障是一种屏障指令,它使得CPU或编译器对屏障指令的前和后所发出的内存操作执行一个排序的约束。也叫内存栅栏或栅栏指令

内存屏障能干嘛?

  • 阻止屏障两边的指令重排序
  • 写数据时假如屏障,强制将线程私有工作内存的数据刷回主物理内存
  • 读数据时加入屏障,线程私有工作内存的数据失效,重新到主物理内存中获取最新数据

内存屏障的四大指令

  • 在每一个volatile写操作前面插入一个StoreStore屏障
    • 普通写和volatile写禁止重排
  • 在每一个volatile写操作后面插入一个StoreLoad屏障
    • volatile写和普通读禁止重排
  • 在每一个volatile读操作后面插入一个LoadLoad屏障
    • volatile读和普通读禁止重排
  • 在每一个volatile读操作后面插入一个LoadStore屏障
    • volatile读和volatile写进行重排

3句话总结文章来源地址https://www.toymoban.com/news/detail-486716.html

  • volatile写之前的的操作,都禁止重排到volatile之后
  • volatile读之后的操作,都禁止重排到volatile之前
  • volatile写之后volatile读,禁止重排序

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

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

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

相关文章

  • DCL 单例模式设计为什么需要 volatile 修饰实例对象

     DCL 问题,是在基于双重检查锁设计下的单例模式中,存在不 完整对象的问题。而这个不完整对象的本质,是因为指令重排序导致的。 当我们使用 instance=new DCLExample()构建一个实例对象的时候,因为 new 这个操作并不是原子的。所以这段代码最终会被编译成 3 条指令: 为对象

    2024年02月08日
    浏览(47)
  • FPGA设计Verilog基础之数据类型的作用和特点、常量和变量的代码示例详解

    注意:后续技术分享,第一时间更新,以及更多更及时的技术资讯和学习技术资料 ,将在公众号 CTO Plus 发布,请关注公众号: CTO Plus 在Verilog中,有多种数据类型可供使用,包括位向量类型、整数类型、实数类型、布尔型、时间类型和字符串类型等。下面详细介绍Verilog的所

    2024年02月03日
    浏览(39)
  • 第六章 Linux 磁盘管理

    如果我们想在系统中增加一块硬盘用于数据存取,那么大概需要以下步骤: 目的,一是为了分割硬盘空间方便管理,更重要的是让各个分区都基本独立开来,这样如果某个区发生问题,至少不会直接影响到其他分区。 举例:如果把一块磁盘比喻成一大块地,那么对磁盘进行

    2024年02月04日
    浏览(54)
  • 第六章 游标

    本文内容较短,我们只是为了更容易的实现b树,简单地重构一下。 我们将添加一个Cursor 表示表中对象的位置。Cursor应提供如下几个方面的能力: 在表的开头创建游标 在表的末尾创建游标 访问=游标指向的行 将游标前进到下一行 这是本文我们要实现的能力,后面我们还希望

    2024年02月15日
    浏览(35)
  • Scala(第六章 面向对象)

    1、 Scala的面向对象思想和Java的面向对象思想和概念是一致的。 2、Scala中语法和Java不同,补充了更多的功能。 1)基本语法 1 2)Scala包的三大作用(和Java一样) 1、区分相同名字的类 2、当类很多时,可以很好的管理类 3、控制访问范围 6.1.1 包的命名 1)命名规则 只能包含数

    2024年02月13日
    浏览(46)
  • 数据结构:第六章 图

    ps:图不可以为空图。 对于图中的边,两头必须要有结点。 边集是可以没有的,如上图最右边。 关于无向图和有向图的应用如下 比如你微信里的好友关系,你要和一个人建立关系(也就是图的两个结点连上),你只需要加1次就可以了,也不需要你加我,我还要加你。 具体

    2024年02月14日
    浏览(44)
  • 第六章 集合引用类型

    6.1 Object         到目前为止,大多数引用值的示例使用的是Object类型。Object是ECMAScript中最常用的类型之一。虽然Object的实例没有多少功能,但很适合存储和在应用程序间交换数据。         显式地创建Object的实例有两种方式。第一种是使用new操作符和Object构造函数,

    2024年01月18日
    浏览(46)
  • 第六章 Python函数

    系列文章目录 第一章 Python 基础知识 第二章 python 字符串处理 第三章 python 数据类型 第四章 python 运算符与流程控制 第五章 python 文件操作 第六章 python 函数 第七章 python 常用内建函数 第八章 python 类(面向对象编程) 第九章 python 异常处理 第十章 python 自定义模块及导入方法

    2024年02月06日
    浏览(42)
  • Python第六章作业

    目录 第1关 列表的属性与方法 第2关 推导式与生成器 第3关 列表的合并与排序 第4关 二维列表排序 第5关 动物重量排序 第6关 身份证号升位 第7关 完美立方数 第8关 约瑟夫环问题 第9关 文本分析(2)——统计英文文件中的单词数 第1关 列表的属性与方法 初始化一个空

    2024年02月05日
    浏览(46)
  • 第六章 矩阵函数

    就是 f ( x ) 变成了 f ( A ) 就是 f(x) 变成了 f(A) 就是 f ( x ) 变成了 f ( A ) 难点在于 A k A^k A k 不好算。 解决方案是利用 J o r d a n Jordan J or d an 标准型来做。 f ( A ) = P d i a g ( f ( J 1 ) , f ( J 2 ) , … , f ( J r ) ) P − 1 Large f(A) = Pdiag(f(J_1),f(J_2),dots,f(J_r))P^{-1} f ( A ) = P d ia g ( f ( J 1 ​

    2024年02月04日
    浏览(31)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包