返回顶部
首页 > 资讯 > 后端开发 > Python >Java中不可或缺的关键字volatile详析
  • 894
分享到

Java中不可或缺的关键字volatile详析

Python 官方文档:入门教程 => 点击学习

摘要

目录什么是volatile关键字保证可见性保证有序性变量初始化赋值懒汉式单例 -- 双重校验锁 volatile版隐藏特性无法保证原子性volatile版synchronized版L

什么是volatile关键字

volatile是Java中用于修饰变量的关键字,其可以保证该变量的可见性以及顺序性,但是无法保证原子性。更准确地说是volatile关键字只能保证单操作的原子性, 比如x=1 ,但是无法保证复合操作的原子性,比如x++

其为Java提供了一种轻量级的同步机制:保证被volatile修饰的共享变量对所有线程总是可见的,也就是当一个线程修改了一个被volatile修饰共享变量的值,新值总是可以被其他线程立即得知。相比于synchronized关键字(synchronized通常称为重量级锁),volatile更轻量级,开销低,因为它不会引起线程上下文的切换和调度。

保证可见性

可见性:是指当多个线程访问同一个变量时,一个线程修改了这个变量的值,其他线程能够立即看到修改的值。我们一起来看一个例子:

public class VisibilityTest {
    private boolean flag = true;
​
    public void change() {
        flag = false;
        System.out.println(Thread.currentThread().getName() + ",已修改flag=false");
    }
​
    public void load() {
        System.out.println(Thread.currentThread().getName() + ",开始执行.....");
        int i = 0;
        while (flag) {
            i++;
        }
        System.out.println(Thread.currentThread().getName() + ",结束循环");
    }
​
    public static void main(String[] args) throws InterruptedException {
        VisibilityTest test = new VisibilityTest();
​
        // 线程threadA模拟数据加载场景
        Thread threadA = new Thread(() -> test.load(), "threadA");
        threadA.start();
​
        // 让threadA执行一会儿
        Thread.sleep(1000);
        // 线程threadB 修改 共享变量flag
        Thread threadB = new Thread(() -> test.change(), "threadB");
        threadB.start();
​
    }
}

其中:threadA 负责循环,threadB负责修改 共享变量flag,如果flag=false时,threadA 会结束循环,但是上面的例子会死循环! 原因是threadA无法立即读取到共享变量flag修改后的值。 我们只需private volatile boolean flag = true;,加上volatile关键字threadA就可以立即退出循环了。

其中Java中的volatile关键字提供了一个功能:那就是被volatile修饰的变量P被修改后,JMM会把该线程本地内存中的这个变量P,立即强制刷新到主内存中去,导致其他线程中的volatile变量P缓存无效,也就是说其他线程使用volatile变量P在时,都是从主内存刷新的最新数据。而普通变量的值在线程间传递的时候一般是通过主内存以共享内存的方式实现的

因此,可以使用volatile来保证多线程操作时变量的可见性。除了volatileJava中的synchronizedfinal两个关键字 以及各种Lock也可以实现可见性。加锁的话, 当一个线程进入 synchronized代码块后,线程获取到锁,会清空本地内存,然后从主内存中拷贝共享变量的最新值到本地内存作为副本,执行代码,又将修改后的副本值刷新到主内存中,最后线程释放锁。

保证有序性

有序性,顾名思义即程序执行的顺序按照代码的先后顺序执行。但现代的计算机中CPU中为了能够让指令的执行尽可能地同时运行起来,提示计算机性能,采用了指令流水线。一个 CPU 指令的执行过程可以分成 4 个阶段:取指、译码、执行、写回。这 4 个阶段分别由 4 个独立物理执行单元来完成。

理想的情况是:指令之间无依赖,可以使流水线的并行度最大化 但是如果两条指令的前后存在依赖关系,比如数据依赖,控制依赖等,此时后一条语句就必需等到前一条指令完成后,才能开始。所以CPU为了提高流水线的运行效率,对无依赖的前后指令做适当的乱序和调度,即现代的计算机中CPU是乱序执行指令的

另一方面,只要不会改变程序的运行结果,Java编译器是可以通过指令重排优化性能。然而,重排可能会影响本地处理器缓存与主内存交互的方式,可能导致在多线程的情况下发生"细微"的BUG。

指令重排一般可以分为如下三种类型:

  • 编译器优化重排序,编译器在不改变单线程程序语义的前提下,可以重新安排语句的执行顺序。
  • 指令级并行重排序,现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性,处理器可以改变语句对应机器指令的执行顺序。
  • 内存系统重排序,由于处理器使用缓存和读 / 写缓冲区,这使得加载和存储操作看上去可能是在乱序执行。这并不是显式的将指令进行重排序,只是因为缓存的原因,让指令的执行看起来像乱序。

从 Java 源代码到最终执行的指令序列,一般会经历下面三种重排序:

编译器优化重排序 - 指令级并行重排序 - 内存系统重排序 - 最终执行的指令排序

变量初始化赋值

我们一起来看一个例子,让大家体悟volatile关键字禁止指令重排的作用:

int i = 0;
int j = 0;
int k = 0;
i = 10; 
j = 1; 

对于上面的代码我们正常的执行流程是:

  • 初始化i
  • 初始化j
  • 初始化k
  • i赋值
  • j赋值

但由于指令重排序问题,代码的执行顺序未必就是编写代码时候的顺序。语句可能的执行顺序如下:

  • 初始化i
  • i赋值
  • 初始化j
  • j赋值
  • 初始化k

指令重排对于非原子性的操作,在不影响最终结果的情况下,其拆分成的原子操作可能会被重新排列执行顺序,提升性能。指令重排不会影响单线程的执行结果,但是会影响多线程并发执行的结果正确性

但当我们用volatile修饰变量k时:

int i = 0;
int j = 0;
volatile int k = 0;
i = 10; 
j = 1; 

这样会保证上面代码执行顺序:变量i和j的初始化,在volatile int k = 0之前,变量i和j的赋值操作在volatile int k = 0后面

懒汉式单例 -- 双重校验锁 volatile版

我们可以使用volatile关键字去阻止重排 volatile变量周围的读写指令,这种操作通常称为 memory barrier (内存屏障)

隐藏特性

volatile关键字除了禁止指令重排的作用,还有一个特性: 当线程向一个volatile 变量写入时,在线程写入之前的其他所有变量(包括非volatile变量)也会刷新到主内存。当线程读取一个 volatile变量时,它也会读取其他所有变量(包括非volatile变量)与volatile变量一起刷新到主内存。 尽管这是一个重要的特性,但是我们不应该过于依赖这个特性,来"自动"使周围的变量变得volatile,若是我们想让一个变量是volatile的,我们编写程序的时候需要非常明确地用volatile关键字来修饰。

无法保证原子性

volatile关键字无法保证原子性 ,更准确地说是volatile关键字只能保证单操作的原子性, 比如x=1 ,但是无法保证复合操作的原子性,比如x++

所谓原子性:即一个或者多个操作作为一个整体,要么全部执行,要么都不执行,并且操作在执行过程中不会被线程调度机制打断;而且这种操作一旦开始,就一直运行到结束,中间不会有任何上下文切换(context switch)

int  = 0;   //语句1,单操作,原子性的操作
​
i++;         //语句2,复合操作,非原子性的操作

其中:语句2i++ 其实在Java中执行过程,可以分为3步:

  • i 被从局部变量表(内存)取出,
  • 压入操作栈(寄存器),操作栈中自增
  • 使用栈顶值更新局部变量表(寄存器更新写入内存)

执行上述3个步骤的时候是可以进行线程切换的,或者说是可以被另其他线程的 这3 步打断的,因此语句2不是一个原子性操作

volatile版

我们再来看一个例子:

public class Test1 {
​
    public static volatile int val;
​
    public static void add() {
        for (int i = 0; i < 1000; i++) {
            val++;
        }
    }
​
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(Test1::add);
        Thread t2 = new Thread(Test1::add);
        t1.start();
        t2.start();
        t1.join();//等待该线程终止
        t2.join();
        System.out.println(val);
    }
}

2个线程各循环2000次,每次+1,如果volatile关键字能够保证原子性,预期的结果是2000,但实际结果却是:1127,而且多次执行的结果都不一样,可以发现volatile关键字无法保证原子性。

synchronized版

我们可以利用synchronized关键字来解决上面的问题:

public class SynchronizedTest {
    public static int val;
​
    public synchronized static void add() {
        for (int i = 0; i < 1000; i++) {
            val++;
        }
    }
​
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(SynchronizedTest::add);
        Thread t2 = new Thread(SynchronizedTest::add);
        t1.start();
        t2.start();
        t1.join();//等待该线程终止
        t2.join();
        System.out.println(val);
    }
}

运行结果:2000

Lock版

我们还可以通过加锁来解决上述问题:

public class LockTest {
​
    public static int val;
​
    static Lock lock = new ReentrantLock();
​
    public static void add() {
​
        for (int i = 0; i < 1000; i++) {
​
            lock.lock();//上锁
            try {
                val++;
            }catch(Exception e) {
                e.printStackTrace();
            }finally {
                lock.unlock();//解锁
            }
​
        }
​
    }
​
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(LockTest::add);
        Thread t2 = new Thread(LockTest::add);
        t1.start();
        t2.start();
        t1.join();//等待该线程终止
        t2.join();
        System.out.println(val);
    }
​
}

运行结果:2000

Atomic版 i++

Java从jdk 1.5开始提供了java.util.concurrent.atomic包(以下简称Atomic包),这个包中的原子操作类, 靠CAS循环的方式来保证其原子性,是一种用法简单、性能高效、线程安全地更新一个变量的方式。

这些类可以保证多线程环境下,当某个线程在执行atomic的方法时,不会被其他线程打断,而别的线程就像自旋锁一样,一直等到该方法执行完成,才由JVM从等待队列中选择一个线程执行。

我们来用atomic包来解决volatile原子性的问题:

public class AtomicTest {
    public static AtomicInteger val = new AtomicInteger();
​
    public static void add() {
        for (int i = 0; i < 1000; i++) {
            val.getAndIncrement();
        }
    }
​
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(AtomicTest::add);
        Thread t2 = new Thread(AtomicTest::add);
        t1.start();
        t2.start();
        t1.join();//等待该线程终止
        t2.join();
        System.out.println(val);
    }
}

运行结果:2000, 如果我们维护现有的项目,如果遇到volatile变量最好将其替换为Atomic 变量,除非你真的特别了解volatile。Atomic 就不展开说了,先挖个坑,以后补上

volatile 原理

当大家仔细读完上文的懒汉式单例 -- 双重校验锁 volatile版,会发现volatile关键字修饰变量后,我们反汇编后会发现 多出了lock前缀指令,lock前缀指令在汇编中 LOCK指令前缀功能如下:

  • 被修饰的汇编指令成为"原子的"
  • 与被修饰的汇编指令一起提供"内存屏障"效果(lock指令可不是内存屏障)

内存屏障主要分类:

  • 一类是可以强制读取主内存,强制刷新主内存的内存屏障,叫做Load屏障Store屏障
  • 另一类是禁止指令重排序的内存屏障,主要有四个分别叫做LoadLoad屏障StoreStore屏障LoadStore屏障、StoreLoad屏障

这4个屏障具体作用:

  • LoadLoad屏障:(指令Load1; LoadLoad; Load2),在Load2及后续读取操作要读取的数据被访问前,保证Load1要读取的数据被读取完毕。
  • LoadStore屏障:(指令Load1; LoadStore; Store2),在Store2及后续写入操作被刷出前,保证Load1要读取的数据被读取完毕。
  • StoreStore屏障:(指令Store1; StoreStore; Store2),在Store2及后续写入操作执行前,保证Store1的写入操作对其它处理器可见。
  • StoreLoad屏障:(指令Store1; StoreLoad; Load2),在Load2及后续所有读取操作执行前,保证Store1的写入对所有处理器可见。它的开销是四种屏障中最大的。在大多数处理器的实现中,这个屏障是个万能屏障,兼具其它三种内存屏障的功能

对于volatile操作而言,其操作步骤如下:

  • 每个volatile写入之前,插入一个 StoreStore,写入以后插入一个 StoreLoad
  • 每个volatile读取之前,插入一个 LoadLoad,读取之后插入一个 LoadStore

我们再总结以下,用volatile关键字修饰变量后,主要发生的变化有哪些?:

  • 当一个线程修改了 volatile 修饰的变量,当修改后的变量写回主内存时,其他线程能立即看到最新值。即volatile关键字保证了并发的可见性
  • 使用volatile关键字修饰共享变量后,每个线程要操作该变量时会从主内存中将变量拷贝到本地内存作为副本,但当线程操作完变量副本,会强制将修改的值立即写入主内存中。
  • 然后通过 CPU总线嗅探机制告知其他线程中该变量副本全部失效,(在CPU层,一个处理器的缓存回写到内存会导致其他处理器的缓存行无效),若其他线程需要该变量,必须重新从主内存中读取。
  • 在x86的架构中,volatile关键字 底层 含有lock前缀的指令,与被修饰的汇编指令一起提供"内存屏障"效果,禁止了指令重排序,保证了并发的有序性

确保一些特定操作执行的顺序,让cpu必须按照顺序执行指令,即当指令重排序时不会把其后面的指令排到内存屏障之前的位置,也不会把前面的指令排到内存屏障的后面;即在执行到内存屏障这句指令时,在它前面的操作已经全部完成;

  • volatile关键字无法保证原子性 ,更准确地说是volatile关键字只能保证单操作的原子性, 比如x=1 ,但是无法保证复合操作的原子性,比如x++

有人可能问赋值操作是原子操作,本来就是原子性的,用volatile修饰有什么意义? 在Java 数据类型足够大的情况下(在 Java 中 longdouble 类型都是 64 位),写入变量的过程分两步进行,就会发生 Word tearing (字分裂) 情况。 JVM 被允许将64位数量的读写作为两个单独的32位操作执行,这增加了在读写过程中发生上下文切换的可能性,多线程的情况下可能会出现值会被破坏的情况

在缺乏任何其他保护的情况下,用 volatile 修饰符定义一个 longdouble 变量,可阻止字分裂情况

参考资料:

《On Java 8》

《Java并发编程

《深入理解JVM虚拟机

总结

到此这篇关于Java中不可或缺的关键字volatile的文章就介绍到这了,更多相关Java关键字volatile内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网!

--结束END--

本文标题: Java中不可或缺的关键字volatile详析

本文链接: https://lsjlt.com/news/175894.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • Java中不可或缺的关键字volatile详析
    目录什么是volatile关键字保证可见性保证有序性变量初始化赋值懒汉式单例 -- 双重校验锁 volatile版隐藏特性无法保证原子性volatile版synchronized版L...
    99+
    2022-12-27
    java关键字volatile作用 java关键字volatile原理 java关键字volatile
  • Java关键字volatile详析
    目录一、可见性二、关于指令重排volatile关键字关于先说它的两个作用: 保证变量在内存中对线程的可见性禁用指令重排 每个字都认识,凑在一起就麻了 这两个作用通常很不容易被我们Ja...
    99+
    2024-04-02
  • java中的volatile关键字
    目录1.volatile实现可见性的原理是什么?2.演示volatile的可见性1.volatile实现可见性的原理是什么? 有volatile变量修饰的共享变量进行写操作的时候汇编...
    99+
    2024-04-02
  • Java Synchronize下的volatile关键字详解
    简介关键词:Synchronize与volatile Synchronize:无论是对于Synchronize同步方法异或是Synchronize块,本质是对某对象或某类加锁,...
    99+
    2024-04-02
  • Java中volatile关键字的作用
    目录一、volatile作用二、什么是可见性三、什么是总线锁和缓存锁四、什么是指令重排序一、volatile作用 可以保证多线程环境下共享变量的可见性通过增加内存屏障防止多个指令之间...
    99+
    2024-04-02
  • JAVA并发中VOLATILE关键字的示例分析
    小编给大家分享一下JAVA并发中VOLATILE关键字的示例分析,相信大部分人都还不怎么了解,因此分享这篇文章给大家参考一下,希望大家阅读完这篇文章后大有收获,下面让我们一起去了解一下吧!并发编程中的三个概念:1.原子性在Java中,对基本...
    99+
    2023-06-15
  • Java中Volatile关键字详解及代码示例
    一、基本概念先补充一下概念:Java内存模型中的可见性、原子性和有序性。可见性:可见性是一种复杂的属性,因为可见性中的错误总是会违背我们的直觉。通常,我们无法确保执行读操作的线程能适时地看到其他线程写入的值,有时甚至是根本不可能的事情。为了...
    99+
    2023-05-30
    java volatile关键字 ava
  • c++中的volatile和variant关键字详解
    目录一、两个长得有点像的变量二、二者的功能三、应用实例四、总结一、两个长得有点像的变量 对volatile关键字,其实很多人只是能用,知道用到啥处,但其实应用的原理并不知道。在一些多...
    99+
    2024-04-02
  • Java中JMM与volatile关键字的学习
    目录JMMvolatile关键字可见性与原子性测试哪些地方用到过volatile?单例模式的安全问题你知道CAS吗?CAS底层原理CAS缺点ABA问题总结JMM JMM是指Java内...
    99+
    2024-04-02
  • java中的volatile关键字怎么使用
    本篇内容介绍了“java中的volatile关键字怎么使用”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!1.volatile实现可见性的原理...
    99+
    2023-06-25
  • Java中的volatile关键字有什么用
    本篇内容主要讲解“Java中的volatile关键字有什么用”,感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷,实用性强。下面就让小编来带大家学习“Java中的volatile关键字有什么用”吧!一、volatile作用可以保证多线程环...
    99+
    2023-06-30
  • Java中static和volatile关键字的区别
    1. 作用范围不同 static关键字:用于创建类级别的变量或方法,所有类的实例共享同一个static变量的副本。 volatile关键字:用于确保一个变量在多线程环境中的可见性,使所有线程都能看到最新的变量值。 2....
    99+
    2023-10-29
    关键字 区别 Java
  • Java中volatile关键字有什么用
    这篇文章将为大家详细讲解有关Java中volatile关键字有什么用,文章内容质量较高,因此小编分享给大家做个参考,希望大家阅读完这篇文章后对相关知识有一定的了解。概述Java语言中关键字 volatile 被称作轻量级的 synchron...
    99+
    2023-06-19
  • Java中volatile关键字实现原理
    前言我们知道volatile关键字的作用是保证变量在多线程之间的可见性,它是java.util.concurrent包的核心,没有volatile就没有这么多的并发类给我们使用。本文详细解读一下volatile关键字如何保证变量在多线程之间...
    99+
    2023-05-31
    java volatile 关键字
  • JAVA并发中VOLATILE关键字的神奇之处详解
    并发编程中的三个概念: 1.原子性 在Java中,对基本数据类型的变量的读取和赋值操作是原子性操作,即这些操作是不可被中断的,要么执行,要么不执行。 2.可见性 对于可见性,Jav...
    99+
    2024-04-02
  • 详解Java并发编程之volatile关键字
    目录1、volatile是什么?2、并发编程的三大特性3、什么是指令重排序?4、volatile有什么作用?5、volatile可以保证原子性?6、volatile 和 sy...
    99+
    2024-04-02
  • 多方面解读Java中的volatile关键字
    目录介绍作用保证变量的可见性:禁止指令重排:不能保证原子性可见性、有序性、原子性不会导致线程阻塞使用场景实现原理happens-before局限性和 synchronized 关键字...
    99+
    2023-05-19
    Java volatile volatile作用 volatile关键字
  • Java volatile关键字特性实例代码分析
    这篇文章主要讲解了“Java volatile关键字特性实例代码分析”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“Java volatile关键字特性实例代码分析”吧!一...
    99+
    2023-07-04
  • java并发编程关键字volatile保证可见性不保证原子性详解
    目录关于可见性关于指令重排volatile关键字可以说是Java虚拟机提供的最轻量级的同步机制,但对于为什么它只能保证可见性,不保证原子性,它又是如何禁用指令重排的,还有很多同学没彻...
    99+
    2024-04-02
  • C语言中volatile关键字的详细介绍
    这篇文章主要讲解了“C语言中volatile关键字的详细介绍”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“C语言中volatile关键字的详细介绍”吧!1. 什么是volatile关键字?v...
    99+
    2023-06-20
软考高级职称资格查询
编程网,编程工程师的家园,是目前国内优秀的开源技术社区之一,形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容,为IT开发者提供了一个发现、使用、并交流开源技术的平台。
  • 官方手机版

  • 微信公众号

  • 商务合作