Java中Volatile关键字

最新推荐文章于 2021-03-29 17:21:10 发布
最新推荐文章于 2021-03-29 17:21:10 发布
阅读量180 收藏
点赞数
分类专栏： java 面试
原文链接：http://blog.cuzz.site/2019/04/16/Java%E5%B9%B6%E5%8F%91%E7%BC%96%E7%A8%8B/
版权
java 同时被 2 个专栏收录
69 篇文章 2 订阅
订阅专栏
面试
57 篇文章 4 订阅
订阅专栏

文章目录


Java内存模型即Java Memory Model，简称JMM。JMM定义了Java 虚拟机(JVM)在计算机内存(RAM)中的工作方式。JVM是整个计算机虚拟模型，所以JMM是隶属于JVM的。

CPU缓存模型

在这里插入图片描述
java线程模型根CPU模型类似，是基于CPU的缓存模型来建立的，java线程内存模型是标准化的，屏蔽掉了底层不同计算机的区别。
在这里插入图片描述

JMM数据原子操作

  • read（读取）：从主内存读取数据
  • load（载入）：将主内存读取到的数据写入工作内存
  • use（使用）：从工作内存读取数据来计算
  • assign（赋值）：将计算好的值重新赋值到工作内存中
  • store（存储）：将工作内存数据写入主内存
  • write（写入）：将store过去的变量值赋值给主内存中的变量
  • lock（锁定）：将主内存变量加锁，标识为线程独占状态
  • unlocl（解锁）：将主内存变量解锁，解锁后其他线程可以锁定改变量

可见性

可见性是一种复杂的属性，因为可见性中的错误总是会违背我们的直觉。通常，我们无法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚至是根本不可能的事情。为了确保多个线程之间对内存写入操作的可见性，必须使用同步机制。

可见性，是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的。也就是一个线程修改的结果。另一个线程马上就能看到。比如：用volatile修饰的变量，就会具有可见性。volatile修饰的变量不允许线程内部缓存和重排序，即直接修改内存。所以对其他线程是可见的。但是这里需要注意一个问题，volatile只能让被他修饰内容具有可见性，但不能保证它具有原子性。比如 volatile int a = 0；之后有一个操作 a++；这个变量a具有可见性，但是a++ 依然是一个非原子操作，也就是这个操作同样存在线程安全问题。
在 Java 中 volatile、synchronized 和 final 实现可见性。

public class VolatileVisiableTest {

    private static   boolean initFlag = false;  //改了感知不到，副本本都是false
//    private static volatile  boolean initFlag = false;
    public static void main(String[] args) throws InterruptedException {
      //模拟一个线程等待
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("waitting data...");
                while (!initFlag){

                }
                System.out.println("============success");
            }
        }).start();

        Thread.sleep(2000);

        //模拟一个线程等待数据
        new Thread(new Runnable() {
            @Override
            public void run() {
            prepareData();
            }
        }).start();
    }

    public static void prepareData(){
        System.out.println("preparing data ...");
        initFlag = true;
        System.out.println("preparing data end...");
    }
}

结果
waitting data...
preparing data ...
preparing data end...

在这里插入图片描述
其中store 后已经写入在主内存还没有wite。

JMM缓存不一致性问题

总线加锁（性能太低）

在这里插入图片描述
cpu从主内存读取数据到高速缓存，会在总线对这个数据加锁，这样其他cpu没法去读或写这个数据，知道这个cpu使用完数据释放锁之后其他cpu才能读取该数据。虽然解决了不同线程的可见性问题，并行执行变成串行执行，性能不行。

MESI缓存一致性协议

多个cpu从主内存读取同一个数据到各自的高速缓存，当其中某个cpu修改了缓存里的数据，该数据会马上同步回主内存，其他cpu通过总线嗅探机制可以感知到数据的变化从而将自己缓存里的数据失效。然后使用数据会重新从主内存读取。
在这里插入图片描述
volatile变量底层开启缓存一致性协议。

Volatile缓存可见性实现原理

底层实现主要通过汇编lock前缀指令，它会锁定折扣内存区域1的缓存（缓存行锁定）并回写到主内存。
IA-32架构软件开发者手册对lock指令的解释：
1）会将当前处理器缓存行的数据立即写回到系统内存。
2）这个写回内存的操作会引起其他CPU里缓存了改内存地址的数据无效（MESI协议）
volatile关键字在store 前加锁lock，写回主内存后unlock。
在这里插入图片描述

原子性（不保证）

并发编程三大特性：可见性，原子性，有序性。
Volatile保证可见性和有序性，但是不保证原子性，保证原子性需要借助synchronized这样的锁机制。其他并发写的时候


    private static final int THREADS_CONUT = 20;
    public static volatile int count = 0; //也可能<20000
//    public static AtomicInteger count = new AtomicInteger(0); //等于20000



    public static void increase() {
        count++;  //不保证原子性，某个线程count++后assign后没有拿到lock，监听总线，将工作内存count失效，丢失本次++
//        count.incrementAndGet();  //保证原子性
        System.out.println(count);
    }

    public static void main(String[] args) {
        Thread[] threads = new Thread[THREADS_CONUT];
        for (int i = 0; i < THREADS_CONUT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 1000; i++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }
}

在这里插入图片描述

如何解决？1）synchronized 太重了，杀鸡用牛刀 2）juc AtomicInteger

CAS

public class AtomicIntegerTest {

    private static final int THREADS_CONUT = 200;
    public static int count = 0;   //可能<20000,线程间没有可见性,以最后写入主内存的那个线程的count值为准.
//    public static volatile int count = 0; //也可能<20000
//    public static AtomicInteger count = new AtomicInteger(0); //等于20000



    public static void increase() {
//    public synchronized static void increase() {
        count++;  //不保证原子性，某个线程count++后assign后没有拿到lock，监听总线，将工作内存count失效，丢失本次++
//        count.getAndIncrement();  //保证原子性，cas  or  count.incrementAndGet();
        System.out.println(count);
    }

    public static void main(String[] args) {
        Thread[] threads = new Thread[THREADS_CONUT];
        for (int i = 0; i < THREADS_CONUT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 1000; i++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }

    }
}

  public final int getAndDecrement() {
        return unsafe.getAndAddInt(this, valueOffset, -1);
    }
    
  public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }
  1. 假设有两个线程AB,根据上面的内存模型来看 AtomicInteger 里面的value原始值为5，即主内存中AtomicInteger的value为5，根据JMM模型，线程A和线程B各自持有一份值为5的value的副本分别到各自的工作内存。
  2. 线程A通过getIntVolatile(var1, var2)拿到value值5， 这时线程A被挂起。
  3. 线程B也通过getlntVolatile(var1, var2)方法获取到value值5， 此时刚好线程B没有被挂起并执行compareAndSwapInt方法比较内存值也为5，成功修改内存值为6，线程B打完收工，一切OK。
  4. 这时线程A恢复，执行compareAndSwapInt方法比较， 发现自己手里的值数字5和主内存的值数字6不一致，说明该值已经被其它线程抢先一步修改过了，那A线程本次修改失败，只能重新读取新来一遍了。
  5. 线程A重新获取value值， 因为变量value被volatile修饰， 所以其它线程对它的修改，线程A总是能够看到，线程A继续执行compareAndSwapInt进行比较替换，直到成功。

cas缺点

1.获取失败一直空转（自旋），给cpu带来很大开销 2） 数量上只能保证一个变量原子性（多个加锁）3.ABA问题（AtomicStampedReference 解决ABA）

ABA

package atomic;

import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;

public class ABATest {
    static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100,1);

    public static void main(String[] args) {
        System.out.println("=====ABA问题产生========");
        new Thread(()->{
            atomicReference.compareAndSet(100,101);
            atomicReference.compareAndSet(101,100);
        },"t1").start();

        new Thread(()->{
            try {
                Thread.sleep(1000);

                System.out.println(Thread.currentThread().getName()+" "+atomicReference.compareAndSet(100,2019)+" "+atomicReference.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t2").start();

        try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("=====ABA问题解决========");
        new Thread(()->{

            //100->101->100
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+"\t 第一次版本号"+stamp);

            try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
            atomicStampedReference.compareAndSet(100,101,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"\t 第二次版本号"+atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(101,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"\t 第三次版本号"+atomicStampedReference.getStamp());

        },"t3").start();

        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+"\t 第一次版本号"+stamp);
            try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); }
            boolean result = atomicStampedReference.compareAndSet(100,2019,stamp,stamp+1);
            System.out.println(Thread.currentThread().getName()+"\t 修改成功否"+result +"\t 当前最新实际版本号："+atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(101,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"\t 当前实际最新值"+atomicStampedReference.getReference());
        },"t4").start();


    }
}

有序性

有序性：在本线程内观察，操作都是有序的；如果在一个线程中观察另外一个线程，所有的操作都是无序的。
java内存模型所保证的是，同线程内，所有的操作都是由上到下的，但是多个线程并行的情况下，则不能保证其操作的有序性。
计算机在执行程序时，为了提高性能，编译器个处理器常常会对指令做重排，一般分为以下 3 种
在这里插入图片描述
单线程环境里面确保程序最终执行的结果和代码执行的结果一致
处理器在进行重排序时必须考虑指令之间的数据依赖性
多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证用的变量能否一致性是无法确定的，结果无法预测
考试先做会做的，不会做的后做。

public void mySort(){
int x = 11; //1
int y = 12; //2
x= x+5; // 3
y = x*x;//4

可能的顺序1234 2134 1324，不可能的属性4在1 和3前，因为有数据依赖性。

在这里插入图片描述

volatile禁止指令重排。

public class ReSortSeqDemo {
    int a = 0;
    boolean flag = false;
    
    public void method01() {
        a = 1;           // flag = true;
                         // ----线程切换----
        flag = true;     // a = 1;
    }

    public void method02() {
        if (flag) {
            a = a + 3;
            System.out.println("a = " + a);
        }
    }

}

如果两个线程同时执行，method01 和 method02 如果线程 1 执行 method01 重排序了，然后切换的线程 2 执行 method02 就会出现不一样的结果。

禁止指令排序

volatile 实现禁止指令重排序的优化，从而避免了多线程环境下程序出现乱序的现象
先了解一个概念，内存屏障（Memory Barrier）又称内存栅栏，是一个 CPU 指令，他的作用有两个：

  1. 保证特定操作的执行顺序
  2. 保证某些变量的内存可见性（利用该特性实现 volatile 的内存可见性）

由于编译器个处理器都能执行指令重排序优化，如果在指令间插入一条 Memory Barrier 则会告诉编译器和 CPU，不管什么指令都不能个这条 Memory Barrier 指令重排序，也就是说通过插入内存屏障禁止在内存屏障前后执行重排序优化。内存屏障另一个作用是强制刷出各种 CPU 缓存数据，因此任何 CPU 上的线程都能读取到这些数据的最新版本。
下面是保守策略下，volatile写插入内存屏障后生成的指令序列示意图：
在这里插入图片描述

下面是在保守策略下，volatile读插入内存屏障后生成的指令序列示意图：
在这里插入图片描述

volatile 性能

volatile 的读性能消耗与普通变量几乎相同，但是写操作稍慢，因为它需要在本地代码中插入许多内存屏障指令来保证处理器不发生乱序执行。
参考:
http://blog.cuzz.site/2019/04/16/Java%E5%B9%B6%E5%8F%91%E7%BC%96%E7%A8%8B/ (volatile 是 Java 虚拟机提供的轻量级的同步机制)
https://blog.csdn.net/kingtok/article/details/105058823 (Jave 面试 CAS就这?底层与原理与自旋锁)
https://www.cnblogs.com/zhengbin/p/5654805.html（Java中Volatile关键字详解）

春天的早晨
关注
专栏目录
[Java] volatile 详详解！
鹜骜的博客
05-03 4972
前言： 要真正搞懂volatile的特性需要与JMM对比来看 JMM（线程安全的保证） JMM：JAVA内存模型（java memory model） 是一种抽象概念，并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（实例字段，静态字段和构成数组对象的元素）的访问方式。 JMM关于同步的规定 线程解锁前，必须把共享变量的值刷新回主内存； 线程加锁前，必须读取主内存的最...
谈谈Java中的volatile
weixin_30897079的博客
03-18 630
内存可见性 留意复合类操作 解决num++操作的原子性问题 禁止指令重排序 总结 内存可见性 　　volatile是Java提供的一种轻量级的同步机制，在并发编程中，它也扮演着比较重要的角色。同synchronized相比（synchronized通常称为重量级锁），volatile更轻量级，相比使用synchronized所带来的庞大开销，倘若能恰当的合理的使用volatile，自然...
Java中Volatile关键字详解
weixin_30411997的博客
07-08 140
一、基本概念 先补充一下概念：Java 内存模型中的可见性、原子性和有序性。 可见性： 　　可见性是一种复杂的属性，因为可见性中的错误总是会违背我们的直觉。通常，我们无法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚至是根本不可能的事情。为了确保多个线程之间对内存写入操作的可见性，必须使用同步机制。 　　可见性，是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的。也...
java中关键字volatile的作用
tankswh的专栏
03-03 753
用在多线程，同步变量。 线程为了提高效率，将某成员变量(如A)拷贝了一份（如B），线程中对A的访问其实访问的是B。只在某些动作时才进行A和B的同步。因此存在A和B不一致的情况。volatile就是用来避免这种情况的。volatile告诉jvm， 它所修饰的变量不保留拷贝，直接访问主内存中的（也就是上面说的A)=========================分割线1==============
Java volatile详解
liuwg1226的专栏
03-29 1033
一　简介 volatile是Java提供的一种轻量级的同步机制。Java 语言包含两种内在的同步机制：同步块（或方法）和 volatile 变量，相比于synchronized（synchronized通常称为重量级锁），volatile更轻量级，因为它不会引起线程上下文的切换和调度。但是volatile 变量的同步性较差（有时它更简单并且开销更低），而且其使用也更容易出错。 二　并发编程的3个基本概念 １．原子性 定义： 即一个操作或者多个操作要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
java中volatile关键字
qqazzx的博客
08-04 1369
一、java中volatile关键字的含义 在java线程并发处理中，有一个关键字volatile的使用目前存在很大的混淆，以为使用这个关键字，在进行多线程并发处理的时候就可以万事大吉。 Java语言是支持多线程的，为了解决线程并发的问题，在语言内部引入了 同步块 和 volatile 关键字机制。 synchronized 同步块大家都比较熟悉，通过 synchronized 关键字来实现，所有加上synchronized 和 块语句，在多线程访问的时候，同一时刻只能有一个线程能够用synchronize
Java中volatile关键字实现原理
08-30
Java中volatile关键字实现原理 volatile关键字是Java语言中的一种机制，用于保证变量在多线程之间的可见性。它是Java.util.concurrent包的核心，没有volatile就没有那么多的并发类供我们使用。本文详细解读一下...
Java中Volatile关键字详解及代码示例
08-28
Java中Volatile关键字详解及代码示例 一、基本概念 在Java中，Volatile关键字是一个非常重要的概念，它与Java内存模型中的可见性、原子性和有序性息息相关。可见性是指线程之间的可见性，一个线程修改的状态对另一...
深入了解Java中Volatile关键字
08-19
深入了解Java中Volatile关键字 Volatile关键字是Java语言中的一种关键字，主要用于解决多线程编程中的可见性、原子性和有序性问题。本文将详细介绍Volatile关键字的相关知识，并通过代码帮助大家更好地理解和学习。...
Java中的关键字volatile详解
08-26
主要介绍了Java中的关键字volatile，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
解析java中volatile关键字
09-02
Java中的`volatile`关键字是多线程编程中的一个重要概念，它的主要作用是解决并发环境下的可见性和有序性问题。在Java内存模型（JMM）中，每个线程都有自己的工作内存，其中包含了线程对共享变量的副本。线程间的...
java volatile详解
fenglllle的博客
07-31 1346
volatile常用于配合CAS和version实现锁机制，乐观锁。适用于读多写少模式。 1. volatile涉及与CPU与内存模型，线程的工作原理，网上找了一个经典图  CPU在轮询执行线程运算的时候，由于CPU的结构   CPU与内存交付有3级缓存机制，会导致缓存不一致性。CPU的缓存越靠近CPU内核core，速度越快 ，容量越小。   多核CPU对线程工作副本，多个线程...
java volatile 关键字
weixin_34381687的博客
10-30 152
volatile 关键字能把 Java 变量标记成"被存储到主存中"。这表示每一次读取 volatile 变量都会访问计算机主存，而不是 CPU 缓存。每一次对 volatile 变量的写操作不仅会写到 CPU 缓存，还会刷新到主存中。实际上从 Java 5 开始，volatile 变量不仅会在读写操作时访问主存，他还被赋予了更多含义。 ...
java中的volatile详解
zyjzyj2的博客
05-18 439
参考资料: 《深入理解java虚拟机》(周志明) java中的volatile详解1. JAVA为什么要有一个volatile修饰符?2. 代码不符合预期的问题2.1 工作内存带来的`可见性`问题2.1.1 jvm内存模型2.1.2 主内存和工作内存的区分带来了什么问题?2.2 各种优化策略带来的`指令重排`问题2.2.1 什么是指令重排序2.2.2 指令重排序带来了什么问题?3. 怎么解决上面的问题?3.1 解决可见性的问题3.2 解决指令重排序带来的问题4. 为什么`volatile`能解决 可见性和.
java中volatile 关键字
最新发布
01-27
在Java中，volatile关键字用于修饰变量，它主要有两个作用：保证变量的内存可见性和禁止指令重排序。具体来说，当一个变量被volatile修饰时，它的值将会被立即更新到主内存中，并且当其他线程访问该变量时，会直接从...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值