5个案例和流程图让你从0到1搞懂volatile关键字!

WorkBench3.2 + VxWorks6.8安装教程 按照FTP连接主机和目标机,将整个VxWorks6.8的安装分为两个部分,一是在主机(win10系统,可以使用虚拟机或者实体机,推荐使用虚拟机)上安装workbench3.2,进行bootrom与VxWroks映像文件的生成,二是在虚拟机上安装VxWorks系统 19.10.10 首先很高兴文章能帮到大家,但由于本人已不做该方向良久,私信和评论的很多问题现在已经无法解答,如果大家有什么问题欢迎... 阅读详情

volatile

随着硬件的提升,机器的核心数从曾经的单核变为多核,为了提升机器的利用率,现在的并发编程变得越来越重要,成为工作中、面试中的重中之重,而为了能够更好的理解、使用并发编程,就应该构建出自己的Java并发编程知识体系。

本篇文章将围绕Java中的volatile关键字,深入浅出的描述原子性、可见性、有序性,volatile的作用、实现原理、使用场景以及涉及到的JMM、伪共享等问题

为了更好的描述volatile,我们先来聊聊它的前置知识:有序性、可见性、原子性

有序性

什么是有序性?

当我们使用高级语言和简单的语法进行编程时,最终还要将语言翻译为CPU认识的指令

由于干活的是CPU,为了加快CPU的利用率,会对我们流程控制的指令进行重排序

在Java内存模型中,指令重排序的规则需要满足先行先发生(happens-before)规则,比如说对一个线程的启动要先行发生于这个线程的其他操作,不能把启动线程的指令重排序到线程执行的任务后面

也就是说在Java内存模型中,指令重排序不会影响我们规定好的单线程执行流程,但在多线程的情况下不能预估各个线程的执行流程

为了更贴切的描述,看下面这一段代码

    static int a, b, x, y;
​
    public static void main(String[] args){
        long count = 0;
        while (true) {
            count++;
            a = 0;b = 0;x = 0;y = 0;
            Thread thread1 = new Thread(() -> {
                a = 1;
                x = b;
            });
            Thread thread2 = new Thread(() -> {
                b = 1;
                y = a;
            });
            thread1.start();
            thread2.start();
​
            try {
                thread1.join();
                thread2.join();
            } catch (Exception e) {}
​
            if (x == 0 && y == 0) {
                break;
            }
        }
        //count=118960,x=0,y=0
        System.out.println("count=" + count + ",x=" + x + ",y=" + y);
    }

初始化 a,b,x,y四个变量都是0

以我们的思维认为执行顺序为

//线程1
a = 1;
x = b;
​
//线程2
b = 1;
y = a;

可是经过指令重排序后,可能出现的四种情况:


//线程1
//1           2           3           4     
a = 1;      a = 1;      x = b;      x = b;        
x = b;      x = b;      a = 1;      a = 1;  
​
//线程2
//1           2           3           4 
b = 1;      y = a;      b = 1;      y = a;
y = a;      b = 1;      y = a;      b = 1;

当出现第4种情况时,x与y都可能为0

那么如何可以保证有序性呢?

使用volatile修饰变量就可以保证有序性

为了提升CPU利用率,会对指令进行重排序,重排序只能保证单线程下流程的运行逻辑

在多线程下无法预估执行顺序,及不能保证有序性,如果想在多线程下保证有序性可以使用volatile,volatile会使用内存屏障禁止指令重排序来实现有序性

也可以直接加锁去保证同步执行

同时可以使用并发包中Unsafe类的内存屏障禁止重排序

//线程1
a = 1;
unsafe.fullFence();
x = b;
​
//线程2
b = 1;   
unsafe.fullFence();
y = a;

可见性

什么又是可见性呢?

在Java内存模型中,每个线程有一份自己的工作内存和主内存,读取数据时需要先从主内存拷贝到工作内存,修改数据时只在自己的工作内存中进行修改,如果多个线程同时操作某个数据,进行修改后未写回主内存,那么其他线程无法感知该数据变动

image-20230823223141451.png

比如下面这一段代码,创建的线程会一直循环,因为它感知不到其他线程对变量进行修改

    //nonVolatileNumber 是未被volatile修饰的
    new Thread(() -> {
        while (nonVolatileNumber == 0) {
    ​
        }
    }).start();
    ​
    TimeUnit.SECONDS.sleep(1);
    nonVolatileNumber = 100;

那么如何让该变量具有可见性呢?

对该变量使用volatile修饰即可保证可见性,也可以通过加锁synchronized的方式,加锁后相当于要重新读取主内存的数据

原子性

什么是原子性?

实际上就是一个或一组操作能否同时完成,如果不能,那他们就必须都失败,而不能一部分执行成功一部分执行失败

Java内存模型中的read、load(上图)指令的原子性由虚拟机实现

使用一个变量的自增来说,实际上需要先从主内存进行读取再修改最后写回主内存

那么volatile能否保证原子性呢?

我们使用两个线程对用volatile修饰的同一变量进行一万次自增

        private volatile int num = 0;
    ​
        public static void main(String[] args) throws InterruptedException {
            C_VolatileAndAtomic test = new C_VolatileAndAtomic();
            Thread t1 = new Thread(() -> {
                forAdd(test);
            });
    ​
            Thread t2 = new Thread(() -> {
                forAdd(test);
            });
    ​
            t1.start();
            t2.start();
    ​
            t1.join();
            t2.join();
    ​
            //13710
            System.out.println(test.num);
        }
    ​
        /**
         * 循环自增一万次
         *
         * @param test
         */
        private static void forAdd(C_VolatileAndAtomic test) {
            for (int i = 0; i < 10000; i++) {
                test.num++;
            }
        }

很可惜,结果并不是20000,说明volatile修饰的变量并不能保证其原子性

那么什么方式能保证原子性呢?

synchronized加锁的方式就可以保证原子性,因为拿到锁同一时间只有它能进行访问

使用原子类,底层使用CAS的方式也可以保证原子性,什么是CAS呢?我们后续文章再来叨叨

volatile原理

经过有序性、可见性、原子性的描述与测试,我们可以知道volatile能够保证有序性和可见性,但不能保证原子性的特点

那么volatile底层又是如何实现有序性与可见性的呢?

JVM会对使用volatile修饰的变量,加上volatile的访问标识,在字节码指令运行时会使用操作系统的内存屏障来禁止指令进行重排序

常用的万能内存屏障是storeload,store1 storeload load2 它禁止写的指令重排到屏障之下,禁止读的指令重排到屏障之上,也就是store写回内存对其他处理器可见(能够感知),后续load 读就从内存中读

volatile汇编指令实现实际上是lock前缀指令

lock前缀指令在单核下没啥影响,因为单核可以保证有序性、可见性以及原子性

lock前缀指令在多核下会在修改数据时,将其写回内存中,写回内存需要确保同时只有一个处理器操作,可以通过锁总线的方式,但其他处理器就不能访问

后续为了提升并发粒度,处理器支持锁缓存时(只锁住缓存行),并通过缓存一致性协议保证不能同时修改同一缓存行数据

写回内存后,通过嗅探技术让其他处理器感知数据变动,在后续使用前重新读取内存

伪共享问题

由于每次读取都是对一个缓存行操作,那么如果多线程频繁对同一缓存行的两个变量进行修改,会不会导致其他用到该缓存行的处理器总是需要重新进行读数据呢?

这其实就是所谓的伪共享问题

比如两个变量i1,i2都在同一个缓存行中,其中处理器1频繁对i1进行写,处理器2频繁对i2进行写,并且i1与i2都被volatile修饰,这也就导致i1被修改时,处理器2感知到缓存行变脏,于是要重新读内存获取最新缓存行,但这样的性能开销对处理器2对i2进行写操作没有任何意义

image-20230824210222603.png

解决伪共享问题的常用办法,就是在这两个字段之间增加足够多的字段,让它们不在同一缓存行上,这样也就会导致浪费空间

为了解决伪共享问题,JDK也提供了@sun.misc.Contended注解来帮我们填充字段

下面的代码,让两个线程循环10亿次去进行自增,当发生伪共享问题时总耗时三十多秒,未发生伪共享问题耗时才几秒

需要注意的是,使用@sun.misc.Contended注解时,需要携带JVM参数-XX:-RestrictContended

        @sun.misc.Contended
        private volatile int i1 = 0;
        @sun.misc.Contended
        private volatile int i2 = 0;
        
        public static void main(String[] args) throws InterruptedException {
            D_VolatileAndFalseSharding test = new D_VolatileAndFalseSharding();
            int count = 1_000_000_000;
            Thread t1 = new Thread(() -> {
                for (int i = 0; i < count; i++) {
                    test.i1++;
                }
            });
    ​
            Thread t2 = new Thread(() -> {
                for (int i = 0; i < count; i++) {
                    test.i2++;
                }
            });
    ​
            long start = System.currentTimeMillis();
    ​
            t1.start();
            t2.start();
    ​
            t1.join();
            t2.join();
    ​
            //31910 i1:1000000000 i2:1000000000
    ​
            //使用@sun.misc.Contended解决伪共享问题  需要携带JVM参数 -XX:-RestrictContended
            //5961 i1:1000000000 i2:1000000000
            System.out.println((System.currentTimeMillis() - start) + " i1:"+ test.i1 + " i2:"+ test.i2);
        }

volatile的使用场景

volatile通过内存屏障来禁止指令重排序,从而保证可见性与有序性

基于可见性的特点,volatile非常适合用在并发编程中的读场景,因为volatile保证可见性,配合不用加锁的读操作,开销非常小

比如:并发包中AQS队列的同步状态status会用volatile修饰

而写操作常常需要进行加锁的同步保证

基于有序性的特点,volatile可以在双重检测锁时,禁止创建对象指令重排序,从而避免其他线程获取到的对象还未初始化

创建对象可以分为三个步骤:

//1.分配内存
//2.初始化对象
//3.将对象指向分配的空间

由于2、3步骤都会依赖1步骤,所以1步骤不能重排序,而2、3步骤没有依赖关系,因此重排序可能会导致先将对象指向分配的空间,再去初始化

如果此时在双重检测锁中,有线程正好判断不为空去使用这个对象,但是此时还未初始化,就可能发生获取到的对象还未初始化的问题

因此正确的双重检测锁需要加上volatile禁止重排序

        private static volatile Singleton singleton;
    ​
        public static Singleton getSingleton(){
            if (Objects.isNull(singleton)){
                //有可能很多线程阻塞到拿锁,拿完锁再判断一次
                synchronized (Singleton.class){
                    if (Objects.isNull(singleton)){
                        singleton = new Singleton();
                    }
                }
            }
    ​
            return singleton;
        }

总结

本篇文章围绕volatile关键字深入浅出的描述有序性、可见性、原子性、JMM、volatile原理、使用场景、伪共享问题等等

为了提升CPU的利用率,会对指令进行重排序,重排序不影响单线程下的指向流程,但多线程下的执行流程不能预测

在Java内存模型中,每个线程都有自己的工作内存,读取数据需要从主内存读取,修改数据需要写回主内存;在并发编程中,当其他线程无法感知到变量被修改时还继续使用就可能出错

volatile通过内存屏障禁止指令重排序以达到满足有序性和可见性,但不能满足原子性

volatile底层汇编使用lock前缀指令实现,在多核下在修改数据时会锁总线将数据写回内存中,由于锁总线开销大,后续使用锁缓存行,同时使用缓存一致性协议保证同时只能一个处理器修改同一缓存行,通过嗅探技术让其他拥有该缓存行的处理器感知到缓存行变脏,后续重新读取

如果多线程频繁写操作的变量在同一缓存行,会出现伪共享问题,此时需要通过填充字段,让它们不处于同一缓存行

volatile基于可见性的特点,常在并发编程中实现无锁的读操作;基于有序性的特点,可以在双重检测锁中保证获取到的实例不是还没初始化的

PCL 直通滤波器【2026最新版】 PCL直通滤波器函数详解以及用于多字段滤波、强度滤波、获取某一时间范围内的点等高阶用法案例分享。博客长期更新,本文最近一次更新时间为:2026年3月11日。 阅读详情

相关推荐

ZYNQ学习:PL端DDR3 读写测试

DDR SDRAM 的最大特点是双沿触发,即在时钟的上升沿和下降沿都能进行数据采集和发送,同样的工作时钟, DDR SDRAM 的读写速度可以比传统的 SDRAM 快一倍。本次实验使用的 DDR3 芯片是南亚的 NT5CC256M16ER-EKI, NT5CC256M16ER-EKI 的 bank 位宽为 3,行位宽为 15,列位宽为 10,所以它的地址大小等于 2^3*2^15*2^10(即 2^28=256M),数据位宽为 16bit,所以容量大小为 256M*16bit,也就是 512MByte。

shuidiQAQ的博客 3035

线程学习(21)-volatile有序性

volatile保证了有序性。这里的有序性,不是前面所说的指令交错的问题,而是指令中更底层的东西。JVM在不影响正确性的情况下,会对语句的执行顺序来进行重排。为了提高指令执行的效率。Clock Cycle Time 主频的概念大家接触的比较多,而 CPU 的 Clock Cycle Time(时钟周期时间),等于主频的倒数,意思是 CPU 能够识别的最小时间单位,比如说 4G 主频的 CPU 的 Clock Cycle Time 就是 0.25 ns,作为对比,我们墙上挂钟的Cycle Time 是 1s

key_wu的博客 904

【电商风控】电商风控标注是什么

本篇文章给大家谈谈。

868

volatile(三) 有序性

1.什么是有序性 程序按照写代码的先后顺序执行,就是有序的。程序难道还能不按代码顺序执行?这就涉及到CPU的指令重排序问题。 2.指令重排 处理器为了提高程序运行效率,可能会对输入代码进行优化,它不保证程序中各个语句的执行先后顺序同代码中的顺序一致,但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。那它如何保证即使重排最终结果也能正确呢? 答案就是保证指令数据间依赖关系不会被重排所影响。看...

liujian8654562的博客 744

JS实例(三)图片的缓慢放大和缩小

  我们经常能看到在一些网站中可以通过按钮实现对图片的放大或者缩小,也有可能是鼠标经过时图片放大。在本例中就是通过JavaScript实现图片的放大和缩小。   首先是进行简单的页面布局 1 <div class="imagedispose"> 2 <img src="1.jpeg" id="imaged" width="400px" height="3...

weixin_34235105的博客 314

Stable Diffusion 模型分享:Beautiful Realistic Asians(美丽真实的亚洲人)

Beautiful Realistic Asians(BRA)模型是由作者自己训练而成的一个独立模型,它是一个真实模型,并且是一个针对亚洲人训练的模型,可以生成非常漂亮的亚洲小姐姐。条目内容类型大模型基础模型SD 1.5来源CIVITAI作者文件名称文件大小1.99GB。

水滴的博客 2161

volatile的用法示例

问题描述 1、两个线程访问共享变量时,值不同步(线程一需等待线程二数据准备好之后再执行业务逻辑,实际却是线程一死循环了) 1)代码如下 public class Voletite { private static boolean initFlag = false;//共享变量 public static void main(String[] args) throws In...

小克马笔记 2093

国科大学习资料--高级软件工程-复习题简答题答案

国科大学习资料–高级软件工程(罗铁坚 魏峻 刘丹)-复习题简答题答案 def fib3 n (1…n).inject([0,1]){|mem| puts mem[0]+mem[1]; [mem[1],mem[0]+mem[1]]} end =====================================================================================================================================

无名何许人的博客 1400

5个案例和流程图让你从0到1搞懂volatile关键字

本篇文章围绕volatile关键字深入浅出的描述有序性、可见性、原子性、JMM、volatile原理、使用场景、伪共享问题等等为了提升CPU的利用率,会对指令进行重排序,重排序不影响单线程下的指向流程,但多线程下的执行流程不能预测在Java内存模型中,每个线程都有自己的工作内存,读取数据需要从主内存读取,修改数据需要写回主内存;在并发编程中,当其他线程无法感知到变量被修改时还继续使用就可能出错volatile通过内存屏障禁止指令重排序以达到满足有序性和可见性,但不能满足原子性。

m0_71777195的博客 198

华为OD机试新系统真题 - 电池充电时间计算

华为OD机试 新系统真题【电池充电时间计算】,提供C语言、Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解,以及在线OJ模拟做题。华为OD机试真题【电池充电时间计算】多语言题解。

qq_45776114的博客 535

AI Agent在智能广告投放中的应用

随着互联网的快速发展,广告投放市场变得越来越复杂和竞争激烈。传统的广告投放方式往往难以精准地触达目标受众,导致广告资源的浪费。AI Agent作为一种智能的自动化程序,能够在复杂的环境中自主学习、决策和执行任务。本文章的目的在于深入探讨AI Agent在智能广告投放中的应用,研究如何利用AI Agent提高广告投放的精准度、效率和效果,降低成本。范围涵盖了AI Agent的基本原理、相关算法、在广告投放中的具体应用场景以及实际案例分析等方面。

欢迎来到我的优快云空间!这里聚焦AI大模型应用实战,分享前沿技术、实战案例与开发经验。 621

volatile能保证有序性

在前面提到volatile关键字能禁止指令重排序,所以volatile能在一定程度上保证有序性。   volatile关键字禁止指令重排序有两层意思:   1)当程序执行到volatile变量的读操作或者写操作时,在其前面的操作的更改肯定全部已经进行,且结果已经对后面的操作可见;在其后面的操作肯定还没有进行;   2)在进行指令优化时,不能将在对volatile变量访问的语句放在其后面执行,...

luzhensmart的专栏 6563

STM32_HAL库—PWM产生指定个数

(一)CubeMX设置: 1. 晶振配置(72M) 2. 引脚配置 3. 中断配置 4. 配置及实现方式 由上推出公式: 机器周期: (72MHz / 36) = 2MHz = 0.5us PWM周期: 0.5 * 100 = 50us = 20kHz 5. 主函数调用PWM函数 HAL_TIM_PWM_Start_IT(&htim3, TIM_CHANNEL_2); //此处一句后可直接进入中断 6. PWM溢出回调函数 void HAL_TIM_PWM_PulseFinished

5527

volatile关键字原理分析

Volatile关键字 对于volatile关键字我们大家都很熟悉,它的可见性,禁止重排序都很了解,但它是如何做到的,jvm是如何保证这些特性的呢? DCL单例为何需要加volatile? 下面我们一起一点点拨开云雾见它实现的底层原理 字节码层面 了解volatile关键字最好的方式是查看字节码及反汇编代码, 这里会使用到HSDIS(Hotspot disassembler)和JITWatch-JIT编译日志分析:工具使用介绍 public class VolatileDemo { p

qq_34368542的博客 267

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

从CPU缓存模型到JMM来理解volatile关键字,复习指南

开头 这个世界都是并发的,编程里更是这样,俗话说:并发知识大,一口吃不下。想成为一名优秀的 Java 开发,学好并发,绝对是你走入高薪行列的必备能力之一。 并发涉及的知识点,其实十分琐碎。学完记不住,记住了用不对。在并发底层原理中,不仅涉及 Java 语言,更涉及 JVM、操作系统、内存、CPU 指令等,令人一头雾水。 这份笔记+学习脑图可以帮你系统地学习Java 并发编程知识,并告别碎片化获取知识的弊端。 Spring Security观后感——手绘思维脑(供参考) 手绘的思维导图,是我自己根据自身的情

m0_56604931的博客 727

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

C语言 static/volatile 关键字:嵌入式开发中 3 个易错场景与内存优化实战

本文深入探讨C语言中static和volatile关键字在嵌入式开发中的关键应用,通过3个典型场景分析易错陷阱与内存优化技巧。重点解析volatile在中断服务程序中的必要性,以及static在模块化编程中的内存管理优势,帮助开发者提升嵌入式系统稳定性和性能。

weixin_33720956的博客 419

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

5分钟从0到1探秘CopyOnWriteArrayList

最近的文章都是围绕并发编程写的,这段时间会写一些并发包下的并发容器,一篇篇文章去解析,彻底搞懂并发包中的并发容器在探秘前,我们先来聊聊并发场景下为什么不能使用ArrayList?ArrayList提供fail-fast快速失败机制,在并发读写场景下通过此机制来抛出并发修改异常以达到快速失败,在并发场景下不安全并发场景下的解决方案有多种,但相对于Vector或来说,加锁粒度更低,性能较好用volatile修饰数组保证其可见性,在读场景下无需加锁在写场景下使用。

关注菜菜的后端私房菜,获取更多技术干货~ 182

你真的了解synchronized和volatile吗?

什么是cas?cas:compare and swap 比较然后交换,它在没有锁的状态下可以保证多线程的对值得更新。我们可以看一下在jdk中对cas的应用:/**  * Atomically increments by one the current value.  *  * @return the updated value  */ public 

yhx12340的博客 230

多线程及并发面试基础(1)——谈谈volatile的理解

对多线程及并发面试基础的小总结 针对面试中的问题,用理论–代码–总结讲各个问题讲清楚。 1、谈谈你对volatile的理解 volatile是Java虚拟机提供的**轻量级**的同步机制。为什么这里是轻量级,而我们要把synchronized当做是重量级的锁。首先看看volatile的三个理论: 保证可见性 不保证原子性(该点正是volatile是轻量级的同步机制的原因) 禁止指令重排 1...

u013025649的专栏 369

Volatile原理概述

前言 今天和大家聊聊 volatile。一个面试频考点,感觉和 synchronized 不分伯仲。 我们都知道,volatile 保证可见性与有序性,但是不保证原子性,保证原子性需要借助 synchronized 这样的锁机制。 所以我们主要围绕着这三个特点来了解 volatile。 JMM 在学习 volatile 之前,我们一定要了解 JMM。 JMM Java 内存模型,它是一种抽象的概念并不真实存在,它描述的是一组规则或规范,通过这组规范定义了程序中各个变量的访问方式。 JMM 关于同步的规定:

weixin_55416758的博客 103

java99流程图_深度分析!面试99%被问到的多线程和并发篇,看完你就懂了

1、Java中实现多线程有几种方法继承Thread类;实现Runnable接口;实现Callable接口通过FutureTask包装器来创建Thread线程;使用ExecutorService、Callable、Future实现有返回结果的多线程(也就是使用了ExecutorService来管理前面的三种方式)。2、如何停止一个正在运行的线程1、使用退出标志,使线程正常退出,也就是当run方法完成...

weixin_36190812的博客 367

Java面试必备:Volatile与Synchronized的区别详解

在Java多线程编程中,`volatile`和`synchronized`都是用于保证线程安全的重要关键字,但它们在实现机制和使用场景上有显著区别。本文将深入探讨两者的差异,并通过流程图帮助理解它们的工作原理。

qq_58299462的博客 824

peterson算法p0流程图,Peterson算法在Java?

Is there example implementation of Peterson algorithm for mutual exclusion in Java?解决方案No one here has provided a correct/safe implementation of this algorithm in Java. I'm not sure how John W's solut...

weixin_29767917的博客 286

12张图一次性搞懂高性能并发容器ConcurrentLinkedQueue

上篇文章聊到并发集合的实现与特点,其不足之处是不适合写多的场景也不适合并发量大的场景本篇文章来聊聊并发场景下高性能的阅读本文大概需要10分钟在阅读本文前,需要理解CAS、volatile等知识如果不理解CAS可以查看这篇文章15000字、6个代码案例、5个原理图让你彻底搞懂Synchronized的第二小节如果不理解volatile可以查看这篇文章5个案例和流程图让你从0到1搞懂volatile关键字基于单向链表实现,使用volatile保证可见性,使得在读场景下不需要使用其他同步机制;

关注菜菜的后端私房菜,获取更多技术干货~ 324

Java volatile与synchronized终极对决:从轻量级标记到重量级同步的全面剖析

volatile是Java中最轻量级的同步机制,它确保共享变量的可见性和有序性,但不保证原子性。是Java的重量级同步机制,它同时保证原子性可见性和有序性,以互斥排他的方式控制并发访问。📌一句话理解:volatile是"通知大家我改了"(轻量级标记);synchronized是"关门独享,谁都别打扰"(重量级锁)。volatile是轻量级的可见性/有序性保障工具,不涉及锁操作;synchronized是全能的互斥同步机制,同时保证原子性、可见性和有序性。

✨ 欢迎来到【Seal ^_^ 的优快云博客】!✨ 227

线程(-)volatile

volatile概念:volatile关键字的主要作用是使变量在多个线程间可见 代码1:isRunning变量并没有设置为volatile 1 package com.java.day01_volatile; 2 3 public class RunThread extends Thread { 4 private boolean isRunning = ...

weixin_30466953的博客 76
上一篇: 容易发生内存泄漏的八个场景,你都知道吗?
下一篇: 10分钟从源码级别搞懂AQS(AbstractQueuedSynchronizer)
加班不秃顶
博客等级 码龄7年 1822粉丝 599原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值