volatile

最新推荐文章于 2024-07-27 09:48:07 发布
最新推荐文章于 2024-07-27 09:48:07 发布
阅读量91 收藏 1
点赞数
分类专栏： 复习 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45607513/article/details/119135725
版权

volatile

volatile:是jvm提供的一种轻量级的同步机制 它保证了可见性和禁止指令重排序，但不保证原子性。

JMM:java内存模型，是一种抽象概念，是一种规范。

JMM同步规范： 1.解锁前，线程必须将值刷新回主内存。
2.加锁前，线程必须将主内存变量的最新值读到工作内存。
3.加锁解锁是同一把锁。

主内存与工作内存： jvm程序运行的实例是线程，线程被创建时，jvm会为每个线程分配一个属于自己的工作内存空间，是线程私有的区域。而主内存是线程共享的区域。主内存中的变量为线程共享，当多线程在计算时，需要将主内存的变量的副本读到自己的工作内存中，在工作内存中完成计算后，再刷新回主内存。

可见性的作用：多线程对变量进行计算时，会把共享变量的副本读到工作内存中，完成计算。这种方式在单线程的情况下没有问题。但是在多线程的情况下，会出现其中一个线程计算完值后，将值刷新到主内存，但是此时其他线程并不知道共享变量被修改了，故而其他线程还会计算一开始的变量值。就会导致计算出问题。

可见性：在多线程操作同一个共享变量时，其中一个线程对变量进行修改后，对其他线程是立即可见的。

可见性验证
package volatiles;

import java.util.concurrent.TimeUnit;

public class visibility {

    /*
     *   volatile:是jvm提供的一种轻量级的同步机制    它保证了可见性和禁止指令重排序，但不保证原子性。
     *   JMM:java内存模型，是一种抽象概念，是一种规范。  JMM同步规范： 1.解锁前，线程必须将值刷新回主内存。
     *                                                       2.加锁前，线程必须将主内存变量的最新值读到工作内存。
     *                                                       3.加锁解锁是同一把锁。
     *
     *   主内存与工作内存： jvm程序运行的实例是线程，线程被创建时，jvm会为每个线程分配一个属于自己的工作内存空间，是线程私有的区域。而主内存是线程共享的
     *                   区域。主内存中的变量为线程共享，当多线程在计算时，需要将主内存的变量的副本读到自己的工作内存中，在工作内存中完成计算后，再刷新回
     *                   主内存。
     *
     *   可见性的作用：多线程对变量进行计算时，会把共享变量的副本读到工作内存中，完成计算。这种方式在单线程的情况下没有问题。但是在多线程的情况下，会出现其中一个线程
     *              计算完值后，将值刷新到主内存，但是此时其他线程并不知道共享变量被修改了，故而其他线程还会计算一开始的变量值。就会导致计算出问题。
     *
     *   可见性：在多线程操作同一个共享变量时，其中一个线程对变量进行修改后，对其他线程是立即可见的。
     * */



    /*
     *    验证可见性
     *
     *    让AAA线程去修改变量n，修改后的n为60；
     * */
    public static void main(String[] args) {

        mod mod = new mod();

        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t come in");

            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            mod.edit();
            System.out.println(Thread.currentThread().getName()+"\t update number value:"+mod.n);
        },"AAA").start();

        while (mod.n==0){//如果main线程的n值等于零，说明AAA线程对n值的修改是对main不可见。

        }
        //AAA线程的值对main不可见，此句不会执行。
        System.out.println(Thread.currentThread().getName()+"\t mission is over"+mod.n);
    }

}

class mod{
    int n = 0;

    public void edit(){

        this.n = 60;

    }
}

没有加volatile关键字。
在这里插入图片描述

class mod{
    volatile int n = 0;

    public void edit(){

        this.n = 60;

    }
}

在这里插入图片描述

原子性
package volatiles;

/*
*  原子性：不可分割的操作，某个线程所做的事情不可以被打断，要么同时成功，要么同时失败。
*
*  验证volatile不保证原子性
* */
public class Atomicity {

    //20个线程对num值进行操作，每个线程执行1000次，如果有原子性结果是20000;
    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.add();
                }

            },String.valueOf(i)).start();
        }

        //当前线程数大于2说明，此时还没算完。2是指后台默认有两个线程，main和守护。
        while (Thread.activeCount()>2){

            Thread.yield();

        }

        System.out.println(Thread.currentThread().getName()+"\t finally number value:"+myData.num);
    }


}

class MyData{

    volatile int num = 0;

    public  void add(){

        num++;

    }


}

在这里插入图片描述
在这里插入图片描述
所以说明volatile不保证原子性。

原因：由于线程计算时会把变量副本读到自己的工作内存中进行计算的。如果线程A对变量进行修改后，由于某些原因被挂起，此时线程B并不知道变量被修改了，线程B还会对原来的变量进行修改，并把修改后的值刷新回主内存，此时线程A把自己空间中的变量刷新回主内存，就会产生写丢失现象。

解决方法：

package volatiles;

import java.util.concurrent.atomic.AtomicInteger;

/*
*  原子性：不可分割的操作，某个线程所做的事情不可以被打断，要么同时成功，要么同时失败。
*
*  验证volatile不保证原子性
* */
public class Atomicity {

    //20个线程对num值进行操作，每个线程执行1000次，如果有原子性结果是20000;
    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.add();
                    myData.addAtomic();
                }

            },String.valueOf(i)).start();
        }

        //当前线程数大于2说明，此时还没算完。2是指后台默认有两个线程，main和守护。
        while (Thread.activeCount()>2){

            Thread.yield();

        }

        System.out.println(Thread.currentThread().getName()+"\t finally number value:"+myData.num);
        System.out.println(Thread.currentThread().getName()+"\t finally number value:"+myData.atomicInteger);
    }


}

class MyData{

    volatile int num = 0;

    public  void add(){

        num++;

    }

    AtomicInteger atomicInteger = new AtomicInteger();

    public void addAtomic(){
        atomicInteger.getAndIncrement();
    }
}

在这里插入图片描述

指令重排

多线程指令重排存在的问题

package volatiles;


/*
*   指令重排：计算机在执行程序的时候，为了提高性能，会将指令重排。也就是说计算机并不保证程序运行的
*           顺序和代码顺序一致，但是可以保证最终结果和代码顺序执行的结果一致。
* */
public class ReSortReqDemo {


    int a = 0;
    boolean flag = false;

    public void method01(){

        a = 1;  //语句1
        flag = true;  //语句2

    }

    /*
    *   在单线程的情况下，发生指令重排不会影响以下结果，结果为6
    *
    *   在多线程的情况下，会出现以下情况。
    *   情况一：线程执行正常，输出6；
    *   情况二：编译器会发生指令重排，线程A执行method01时先执行语句2后，还没有等到执行语句1时，
    *         线程B就执行了method02方法，导致最终结果为5；
    *
    * */
    public void method02(){

        if(flag){

            a = a+5;
            System.out.println("******"+5);

        }

    }

}

单例模式下存在的问题

package volatiles;

public class SingletonDemo {

    private static SingletonDemo instance = null;

    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName()+"\t 我是构造方法SingletonDemo()");
    }

    public static SingletonDemo getInstance(){

        if(instance == null){
            instance = new SingletonDemo();
        }
        return instance;

    }

    public static void main(String[] args) {
        //单线程情况下：只会创建一次对象，调用一次构造方法
        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());

        //多线程下的单例模式
        for(int i=0; i < 10 ; i++){
            new Thread(()->{

                SingletonDemo.getInstance();

            },String.valueOf(i)).start();
        }
    }
}

单线程情况执行的结果：
在这里插入图片描述
多线程情况执行的结果：
在这里插入图片描述
可以看到，在多线程情况下执行的次数小于10次。

解决方法：
1.可以在方法上加synchronized。（不推荐）
2.DCL(Double Check Lock，双端检锁机制)

单例模式DCL代码
package volatiles;

public class SingletonDemo {

    private static SingletonDemo instance = null;

    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName()+"\t 我是构造方法SingletonDemo()");
    }


    //DCL(Double Check Lock,双端检锁机制)
    public static SingletonDemo getInstance(){

        if(instance == null){

            synchronized (SingletonDemo.class){
                if(instance == null){
                    instance = new SingletonDemo();
                }
            }

        }
        return instance;

    }

    public static void main(String[] args) {
        //单线程情况下：只会创建一次对象，调用一次构造方法
        /*System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
*/
        //多线程下的单例模式
        for(int i=0; i < 10 ; i++){
            new Thread(()->{

                SingletonDemo.getInstance();

            },String.valueOf(i)).start();
        }
    }
}

在这里插入图片描述
但是还是会出现安全，因为计算机会出现指令重排，虽然出问题的概率很小。

DCL机制不一定线程安全，原因是有指令重排的存在，加入volatile可以禁止指令重排。

原因在于某一个线程执行到第一次检测，读到的instance不为null时，instance的引用对象可能没有完成初始化。

需要加volatile禁止指令重排。

package volatiles;

public class SingletonDemo {

    private static volatile SingletonDemo instance = null;

    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName()+"\t 我是构造方法SingletonDemo()");
    }


    //DCL(Double Check Lock,双端检锁机制)
    public static SingletonDemo getInstance(){

        if(instance == null){

            synchronized (SingletonDemo.class){
                if(instance == null){
                    instance = new SingletonDemo();
                }
            }

        }
        return instance;

    }

    public static void main(String[] args) {
        //单线程情况下：只会创建一次对象，调用一次构造方法
        /*System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
*/
        //多线程下的单例模式
        for(int i=0; i < 10 ; i++){
            new Thread(()->{

                SingletonDemo.getInstance();

            },String.valueOf(i)).start();
        }
    }
}
丿沐染烟忱丶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java volatile关键字最全总结：原理剖析与实例讲解(简单易懂)
夏日清风
06-13 21万+
本文从Java的内存模型和线程的工作原理出发，对volatile关键字进行介绍。帮助读者深入理解volatile的工作机制。同时，还通过简单易懂的示例讲解了如何正确地使用volatile关键字实现线程安全，避免常见的多线程安全问题。
Java的Volatile实例用法及讲解
08-25
Java的Volatile实例用法及讲解 Java的Volatile关键字是Java语言中一种特殊的修饰符，在多线程编程中发挥着重要作用。Volatile关键字主要在可见性中发挥作用，保证了变量的可见性，使得变量的变化可以被其他线程立即...
Volatile关键字的作用
热门推荐
FighterLiu的专栏
04-24 7万+
Volatile关键字的作用主要有如下两个： 1.线程的可见性：当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。 2. 顺序一致性：禁止指令重排序。 一、线程可见性 我们先通过一个例子来看看线程的可见性： public class VolatileTest { boolean flag = true; public void updateFlag() { this.flag = false; System.out.println("修改flag
volatile详解
一念永恒
12-27 2万+
 volatile这个关键字可能很多朋友都听说过，或许也都用过。在Java 5之前，它是一个备受争议的关键字，因为在程序中使用它往往会导致出人意料的结果。在Java 5之后，volatile关键字才得以重获生机。 　　volatile关键字虽然从字面上理解起来比较简单，但是要用好不是一件容易的事情。由于volatile关键字是与Java的内存模型有关的，因此在讲述volatile关键之前，我们先...
Volatile
m0_37163942的博客
05-06 3866
内存可见性 　　volatile是Java提供的一种轻量级的同步机制，在并发编程中，它也扮演着比较重要的角色。同synchronized相比（synchronized通常称为重量级锁），volatile更轻量级，相比使用synchronized所带来的庞大开销，倘若能恰当的合理的使用volatile，自然是美事一桩。 　　为了能比较清晰彻底的理解volatile，我们一步一步来分析。首先...
Java中的volatile
HGW的博客
06-28 2万+
​ volatile是Java提供的一种轻量级的同步机制，在并发编程中，它也扮演着比较重要的角色。同synchronized相比（synchronized通常称为重量级锁），volatile更轻量级，相比使用synchronized所带来的庞大开销，倘若能恰当的合理的使用volatile，自然是美事一桩。为了能比较清晰彻底的理解volatile，我们一步一步来分析。首先来看看如下代码 上面这个例子，模拟在多线程环境里，t1线程对flag共享变量修改的值能否被t2可见，即是否输出 “-----flag被设置为
volatile关键字详解
努力分享一些干货内容，纯干货，没有一点水
07-12 921
缓存一致性协议: 每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器要对这个数据进行修改操作的时候，会强制重新从系统内存里把数据读到处理器缓存里。在多线程环境下，CPU轮流切换线程执行，有可能某个线程修改了数据，准备回主内存，此时CPU切换到另一个线程修改了数据，并且写回到了主内存，此时就导致数据的不准确。的作用就是，当某个线程工作内存中的值与主内存中的值，如果不相同就会一直。
volatile 原理
小鲁蛋的博客
10-14 2450
volatile 是 Java 提供的一种轻量级的同步机制。Java 语言包含两种内在的同步机制：同步块（或方法）和 volatile 变量，相比于synchronized（synchronized通常称为重量级锁），volatile更轻量级，因为它不会引起线程上下文的切换和调度。但是volatile 变量的同步性较差（有时它更简单并且开销更低），而且其使用也更容易出错。
volatile与指针
Lin的博客
07-28 1893
目录前言使用环境 前言 volatile ˈ/välədl/ 在嵌入式工作中经常会使用到，因此掌握volatile的使用非常重要。 使用环境 多任务环境下任务之间共享标志。 寄存器映射的硬件寄存器
Volatile vs Atomic
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
07-27 5666
volatile和atomic这两个关键字经常会出现在我们的视线中。它们虽然看似相似，实则功能大不相同。
Java中Volatile的作用实例解析
08-27
Java 中 Volatile 的作用实例解析 Volatile 变量在 Java 语言中扮演着重要的角色，它可以被看作是一种 “程度较轻的 synchronized”；与 synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少...
详解java如何正确使用volatile
08-27
Java中的`volatile`关键字在多线程编程中扮演着至关重要的角色，它的主要功能是确保在并发环境中，被volatile修饰的变量对所有线程都具有实时可见性，并且禁止指令重排序。理解`volatile`的工作原理有助于我们更好地...
Volatile.pdf
04-13
标题“Volatile.pdf”和描述“Volatile”暗示文档的内容集中在Java编程语言中的volatile关键字上。Volatile是一个同步关键字，用于提供内存可见性和防止指令重排序，特别是在多线程环境中。在Java中，volatile关键字...
volatile变量详解
12-31
volatile 变量详解 volatile 变量是一种特殊类型的变量，关键字 volatile 作为指令关键字，确保本条指令不会因编译器的优化而省略，且要求每次直接读值。简单地说就是防止编译器对代码进行优化。 volatile 变量的...
独占锁(写锁)/共享锁(读锁)/互斥锁
weixin_45607513的博客
07-29 1824
理论 独占锁：指该锁一次只能被一个线程所持有。对于ReentrantLock和Synchronized而言都是独占锁。 共享锁：该锁可以被多个线程所持有。对于ReentrantReadWriteLock来说，其读锁是共享锁，写锁是独占锁。读锁的共享锁可保证并发读是非常高效的，读写，写读，读读的过程是互斥的。 代码验证 加锁前： package locks; import java.util.HashMap; import java.util.Map; import java.util.concurrent
String中的intern()方法
weixin_45607513的博客
08-19 592
案例 此案例是《深入理解java虚拟机》中的一个案例。 package javase; public class StringPool58Demo { public static void main(String[] args) { String str1 = new StringBuilder("ha").append("llo").toString(); System.out.println(str1); System.out.println(
CAS底层原理
weixin_45607513的博客
07-27 326
CAS cas(比较与替换)。 源码： /** * Atomically sets the value to the given updated value * if the current value {@code ==} the expected value. * * @param expect the expected value * @param update the new value * @return {@code true} if
AQS(AbstractQueuedSynchronizer)
weixin_45607513的博客
08-20 314
前置知识 公平锁和非公平锁、可重入锁、LockSupport、自旋锁、数据结构之链表、设计模式值模板设计模式。 是什么 字面意思是抽象的队列同步器。 源代码结构 AbstractQueuedSynchronizer简称AQS。 技术解释 它是用来构建锁或者其他同步器组件的重量级基础框架及整个JUC体系的基石，通过内置的FIFO队列来完成线程获取资源的排队工作，并通过一个int类型变量表示持有锁的状态。 大致意思就是： 当某个线程抢占锁资源后，其他线程被阻塞，这些被阻塞的线程怎么才能更好的管理呢？就是通过
volatile 作用
最新发布
08-03
`volatile`关键字在C#和其他面向对象编程语言中，用于标记一个字段的值可能在任意时间点被改变，这通常是由于底层硬件操作、线程间的通信或者其他不可预测的原因。它的主要作用包括： 1. **阻止指令重排序（Memory Reordering）**：在多核处理器上，编译器或CPU为了提高性能可能会调整内存访问的顺序。`volatile`告诉编译器和运行时系统不要优化涉及该变量的读写，确保每次读取都看到最新的值。 2. **确保可见性（Visibility）**：在多线程环境，`volatile`可以保证同一时刻，所有线程都能看到对volatile变量的最新更新。这对于共享数据的同步非常重要。 3. **避免读取脏数据（Read of Uninitialized Memory）**：对于可能未初始化就使用的volatile变量，编译器不会假设其已为0或其他初始值，而是强迫线程每次读取前都从内存获取实际值。 需要注意的是，`volatile`并不能解决所有的并发问题，例如它无法防止数据竞争或死锁。它应该作为其他同步技术如锁、信号量的补充，仅用于标记那些可能被意外修改的共享变量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值