JUC_volatile使用

已于 2022-03-31 18:55:40 修改
阅读量109 收藏
点赞数
分类专栏： JUC 文章标签： java
于 2022-03-29 22:26:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35537301/article/details/123832163
版权

一、前提（JMM）

1、JMM概念

JMM（Java内存模型）本身是一种抽象的概念并不真实存在，它描述的是一组规则或者规范，通过这组规范定义了程序中各个变量（包含实例字段，静态字段和构成数组对象的元素）的访问方式

2、JMM同步的规定

  1. 线程解锁前，必须把共享变量的值刷新会主内存
  2. 线程加锁前，必须读取主内存的最新值到自己的工作内存
  3. 加锁和解锁是同一把锁

3、补充说明

由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存（有些地方称为栈空间），工作内存是每个线程的私有数据区域，而Java内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作（读取赋值等）必须在工作内存中进行，首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，各个线程中的工作内存中存储这主内存中的变量副本拷贝，因此不同的线程间无法访问对方的工作内存，线程之间的通信（传值）必须通过主内存来完成

二、概述

1、说明

volatile是Java虚拟机提供的轻量级的同步机制

2、特性：

  • 保证可见性
  • 不保证原子性
  • 禁止指令重排

三、代码验证

3.1代码验证可见性

3.1.1未加volatile处理

package com.atguigu.juc;

import java.util.concurrent.TimeUnit;

class MyData {
    int number = 0;

    public void addT060() {
        this.number = 60;
    }
}

/**
 * 1.验证volatile的可见性
 * 1.1 假如 int number = 0; number变量之前一直没有用volatile关键字修饰
 */
public class VolatileDemo {
    public static void main(String[] args) {//一切方法的运行入口
        MyData myData = new MyData();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t come in");
            try {
                TimeUnit.SECONDS.sleep(3);
                myData.addT060();
                System.out.println(Thread.currentThread().getName() + "\t update number value:" + myData.number);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AAA").start();

        //
        while (myData.number == 0) {
            //main线程一致在这里等待循环,直到number值不等于0
        }
        System.out.println(Thread.currentThread().getName() + "\t mission is over , main get number value:" + myData.number);
    }
}

 3.1.2添加volatile处理

package com.atguigu.juc;

import java.util.concurrent.TimeUnit;

class MyData {
    volatile int number = 0;

    public void addT060() {
        this.number = 60;
    }
}

/**
 * 1.验证volatile的可见性
 * 1.1 假如 int number = 0; number变量之前一直没有用volatile关键字修饰
 */
public class VolatileDemo {
    public static void main(String[] args) {//一切方法的运行入口
        MyData myData = new MyData();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t come in");
            try {
                TimeUnit.SECONDS.sleep(3);
                myData.addT060();
                System.out.println(Thread.currentThread().getName() + "\t update number value:" + myData.number);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AAA").start();

        //
        while (myData.number == 0) {
            //main线程一致在这里等待循环,直到number值不等于0
        }
        System.out.println(Thread.currentThread().getName() + "\t mission is over , main get number value:" + myData.number);
    }
}

 3.2代码验证不保证原子性

package com.atguigu.juc;

import java.util.concurrent.TimeUnit;

class MyData {
    volatile int number = 0;

    public void addT060() {
        this.number = 60;
    }
    //请注意此时number 是用volatile进行修饰的
    public void addPlusPlus() {
        number++;
    }
}

/**
 * 1.验证volatile的可见性
 *      1.1 假如 int number = 0; number变量之前一直没有用volatile关键字
 *      1.2 添加了volatile可以解决可见性问题
 * 2.验证volatile不保证原子性
 *      2.1原子性指的是什么意思?
 *          不可分割,完整性,也即某个线程正在做某个具体业务时,中间不可以被加塞或者被分割
 *          需要整体完整,要么同时成功,要么同时失败
 *      2.2volatile不保证原子性演示
 */
public class VolatileDemo {
    public static void main(String[] args) {//一切方法的运行入口
        MyData myData = new MyData();
        for (int i = 1; i <= 20; i++) {
            new Thread(() ->{
                for (int j = 1; j <= 1000; j++) {
                    myData.addPlusPlus();
                }
            }, String.valueOf(i)).start();
        }
        //需要等待上面20个线程全部计算完成后,再用main线程去的最终的结果值是多少?
        while (Thread.activeCount()>2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"\t finally number value:"+myData.number);
    }

    //volatile可以保证可见性，及时通知其他线程，主物理内存的值已经被修改
    public static void seeOkVolatile() {
        MyData myData = new MyData();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t come in");
            try {
                TimeUnit.SECONDS.sleep(3);
                myData.addT060();
                System.out.println(Thread.currentThread().getName() + "\t update number value:" + myData.number);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AAA").start();

        //
        while (myData.number == 0) {
            //main线程一致在这里等待循环,直到number值不等于0
        }
        System.out.println(Thread.currentThread().getName() + "\t mission is over , main get number value:" + myData.number);
    }
}

如何解决

package com.atguigu.juc;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

class MyData {
    volatile int number = 0;

    public void addT060() {
        this.number = 60;
    }
    //请注意此时number 是用volatile进行修饰的
    public void addPlusPlus() {
        //1.获得;2.增加;3:写回
        number++;
    }

    AtomicInteger atomicInteger = new AtomicInteger();
    public void addMyAtumic(){
        atomicInteger.getAndIncrement();
    }
}

/**
 * 1.验证volatile的可见性
 *      1.1 假如 int number = 0; number变量之前一直没有用volatile关键字
 *      1.2 添加了volatile可以解决可见性问题
 * 2.验证volatile不保证原子性
 *      2.1原子性指的是什么意思?
 *          不可分割,完整性,也即某个线程正在做某个具体业务时,中间不可以被加塞或者被分割
 *          需要整体完整,要么同时成功,要么同时失败
 *      2.2volatile不保证原子性演示
 *
 *      2.3为什么?
 *
 *      2.4如何解决原子性?
 *          *加 sync
 *          *
 */
public class VolatileDemo {
    public static void main(String[] args) {//一切方法的运行入口
        MyData myData = new MyData();
        for (int i = 1; i <= 20; i++) {
            new Thread(() ->{
                for (int j = 1; j <= 1000; j++) {
                    myData.addPlusPlus();
                    myData.addMyAtumic();
                }
            }, String.valueOf(i)).start();
        }
        //需要等待上面20个线程全部计算完成后,再用main线程去的最终的结果值是多少?
        while (Thread.activeCount()>2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"\t int type, finally number value:"+myData.number);
        System.out.println(Thread.currentThread().getName()+"\t AtomicInteger type, finally number value:"+myData.atomicInteger);
    }

    //volatile可以保证可见性，及时通知其他线程，主物理内存的值已经被修改
    public static void seeOkVolatile() {
        MyData myData = new MyData();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t come in");
            try {
                TimeUnit.SECONDS.sleep(3);
                myData.addT060();
                System.out.println(Thread.currentThread().getName() + "\t update number value:" + myData.number);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AAA").start();

        //
        while (myData.number == 0) {
            //main线程一致在这里等待循环,直到number值不等于0
        }
        System.out.println(Thread.currentThread().getName() + "\t mission is over , main get number value:" + myData.number);
    }
}

 3.3指令重排

冰蓝心灵
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java Volatile 的应用场景
来啊 快活啊
08-05 6229
4.4 volatile的应用场景 4.4.1 正确使用volatile条件 条件一： 写入变量时并不依赖变量的当前值；或者能够确保只有单一线程能够修改变量的值 条件二： 变量不需要与其他的状态变量共同参与不变约束 条件三： 变量访问不需要额外加锁 通俗点： 当一个变量依赖其他变量或变量的新值依赖旧值时，不能用volatile 4.4.2 volatile使用场景 适用场合：多个线程读，一个线程写的场合 使用场景：通常被 作为标识完成、中断、状态的标记，值变化应具有原子性 充分利用其可见性：即volatil
JUC —— Volatile
weixin_46540606的博客
02-09 985
Volatile Volatile是java虚拟机提供的轻量级的同步机制 保证可见性 不保证原子性 禁止指令重排序 什么是JMM JMM：java内存模型，不存在的东西，是一个概念、一个约定 关于JMM的一些同步的约定： 线程解锁前，必须把共享变量立刻刷会主存 线程加锁前，必须读取主存中的最新值到工作内存中 加锁和解锁是同一把锁 线程 工作内存 主内存 JMM八种操作 关于主内存与工作内存之间的交互协议，即一个变量如何从主内存拷贝到工作内存。如何从工作内存同步到主内存中的实现细节。java内存模型
【JUC并发编程 】 详解Java关键字之 volatile
最新发布
2401_84002542的博客
05-01 611
各位读者，由于本篇幅度过长，为了避免影响阅读体验，下面我就大概概括了整理了j **加上 synchronized 和 Lock来保证原子性**# 最后各位读者，由于本篇幅度过长，为了避免影响阅读体验，下面我就大概概括了整理了[外链图片转存中...(img-NRO7y6W2-1714513465579)]
java基础：Java中volatile关键字详解
maligebilaowang的博客
03-22 1429
大家都知道，计算机在执行程序时，每条指令都是在CPU中执行的，而执行指令过程中，势必涉及到数据的读取和写入。由于程序运行过程中的临时数据是存放在主存（物理内存）当中的，这时就存在一个问题，由于CPU执行速度很快，而从内存读取数据和向内存写入数据的过程跟CPU执行指令的速度比起来要慢的多，因此如果任何时候对数据的操作都要通过和内存的交互来进行，会大大降低指令执行的速度。因此在CPU里面就有了高速缓存。 也就是，当程序在运行过程中，会将运算需要的数据从主存复制一份到CPU的高速缓存当中，那么CPU进行计算时就可
JUC学习：volatile与内存屏障
qq_45266399的博客
10-26 2170
volatile的概念与读写流程，内存屏障的概念与作用，以及volatile如何实现了其可见性与有序性。
Java中volatile的用法
wlm123666的博客
08-11 1780
volatile 起到的效果是辅助保证线程安全，volatile能够禁止指令重排序，保证内存可见性，但是不保证原子性。主要用于读写同一个变量。 观察如下代码： public class TestVolatile { static class Counter{ public int flag = 0; public int x = 0; } public static void main(String[] args) { Counter
尚硅谷Java视频_JUC 视频教程
02-17
尚硅谷_JUC线程高级_volatile 关键字与内存可见性 ·2. 尚硅谷_JUC线程高级_原子变量与 CAS 算法 ·3. 尚硅谷_JUC线程高级_模拟 CAS 算法 ·4. 尚硅谷_JUC线程高级_同步容器类ConcurrentHashMap ·5. 尚硅谷_JUC...
JUC包含线程,线程池,CAS,volatile等底层原理,以及相关问题的解决方式以及相关工具类的使用
03-31
JUC包括线程、线程池、CAS（Compare and Swap）操作、volatile关键字以及其他相关的底层原理和解决方案。 **synchronized底层原理** synchronized是Java中的内置锁，它在字节码层面表现为monitorenter和monitorexit...
Java volatile与AQS锁内存可见性
09-11
从JUC中的AQS引入，讲解Java volatile与AQS锁内存可见性
tuling-juc-final.zip
05-23
本项目"tuling-juc-final.zip"显然聚焦于Java并发编程的实践，通过一系列代码示例来演示和解释Java内存模型（JMM）、`synchronized`关键字以及`volatile`关键字的使用。下面我们将深入探讨这些核心概念。 Java内存...
JUC并发编程系列详解篇七（volatile关键字详解）
m0_46198325的博客
03-30 1061
java并发编程知识体系详解篇五（volatile关键字详解）
Java内存模型
诺浅的专栏
07-22 383
什么是Java内存模型 java内存模型(JMM)全称为Java Memory Model，是java虚拟机为了java程序能够正常运行而制定的一套规范，规范中规定了JVM中的数据如何与RAM的数据进行交互。 Java内存模型是怎样的 我们知道，在Java中，实例字段、静态字段和构成数组对象的元素是线程共享的，但局部变量与方法参数是线程私有的，不会被共享。所以以下我们所讲的变量等均指线程共享的数据，而非线程私有的数据。 Java 内存模型中规定了所有的变量都存储在主内存中，每个线程还有自己的工作内存（类比缓
JUC并发编程-volatile详解
qq_50596778的博客
01-26 419
volatile详解 三大特性 1.保证可见性 可见性问题主要指一个线程修改了共享变量值，而另一个线程却看不到。引起可见性问题的主要原因是每个线程拥有自己的一个高速缓存区——线程工作内存。volatile关键字能有效的解决这个问题 package TestVolatile; public class TestVolatile { public static void main(String[] args) throws InterruptedException { Data da
JUC-volatile
江黎
10-07 136
volatile的两大特点： 1、可见性 2、有序性 （不保证原子性） 内存屏障也称内存栅栏，是一类同步屏障指令，是cpu或编译器在对内存随机访问的操作中的一个同步点，使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作，避免代码重排序。内存屏障其实是一种JVM指令，Java内存模型的重排序规则要求Java编译器在生成JVM指令时插入特定的内存屏障指令，通过这些内存屏障指令，volatile实现了Java内存模型中的可见性和有序性，但volatile无法保证原子性。 内存屏障之前的所有写操.
JUC篇之volatile关键字（一）
qq_29073117的博客
04-07 175
JUC篇之volatile关键字（一）JUC简介1、内存可见性2、内存可见性错误3、原子性4、volatile关键字验证volatile的内存可见性 JUC简介 1、内存可见性 当多个多个线程对同一变量进行操作的时候，如果其中一个线程对该变量进行了修改操作，可以保证能够被其他线程看到该变量的变化，称之为内存可见性。可以使用volatile保证可见性，也可以用synchronized。 2、内存可见...
JUC(一)之volatile
先
03-10 207
1. volatile的作用? 保证内存可见性 不保证原子性 防止指令重排序 2.验证保证内存可见性 下面来看一段代码 import java.util.concurrent.TimeUnit; public class VolatileDemo { private static int num=0; public static void main(String[] ar...
volatile在java中的应用
天马行空的创作中心
05-24 129
volatile在java中的应用 线程之间的可见性 主内存一个常量，不同线程之前保持可见性，只需要在定义常量的时候增加 volatile。 private volatile int count=1; 其中线程a和线程b通过volatile关键字保持共享数据。具体流程是当线程a从主内存中读取count=1，然后修改count=2之后刷新主内存为count=2，然后使线程b的count值失效，线程b需要再次从主内存中读取count。 之所以不同线程用工作内存，而不是直接从主内存中操作是从性能方面考虑的。
JUC-JMM & volatile
l_dongyang的博客
11-24 213
一、前言 本文意在讲解java中volatile关键字的作用以及原理，因为该关键字可以说是JMM模型封装底层原语而提供出来的API，他的实现涉及到cpu的指令以及线程内存与主存间的交互过程，因此本文会从cpu到缓存内存，再到线程以及JMM，通过简单的介绍线程、缓存、cpu的大致流程后，在此基础之上讲解volatile的作用以及原理，以便于更加深刻的理解volatile关键字的含义。 二、计算机...
深入理解Java volatile与AQS锁的内存可见性
本文将深入探讨Java中的两个关键概念——Java Util Concurrent (JUC)框架中的AQS（AbstractQueuedSynchronizer）和volatile关键字，以及它们在内存可见性和线程同步中的作用。首先，我们将从AQS入手，它是JUC库中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值