JUC之volatile关键字详解

最新推荐文章于 2024-03-16 10:47:52 发布
最新推荐文章于 2024-03-16 10:47:52 发布
阅读量560 收藏 1
点赞数 2
分类专栏： Java基础 文章标签： JUC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PeterPan_pyy/article/details/80962214
版权
一、JUC简介

  •     在Java5.0提供了java.util.concurrent（简称JUC包），在此包中增加了在并发编程中很常用的工具类，在用于定义类似于线程的自定义子系统，包括线程池，异步IO和轻量级任务框架；还提供了设计用于多线程上下文中的Collection实现等。

二、volatile关键字

  • volatile关键字：当多个线程进行共享数据时，可以保证内存中的数据时可见的；相比较于syschronized是一种较为轻量级的同步策略。
  • volatile不具备“互斥性”。
  • volatile不能保证变量的“原子性”。
    下面举一个列子：
 
package com.itszt;

public class Test {
    public static void main(String[] args) throws InterruptedException {

        MyThread myThread = new MyThread();
        System.out.println("开启子线程");
        myThread.start();
        System.out.println("子线程开启完毕");
        Thread.sleep(2000);
        System.out.println("在主线程中终止子线程");
        myThread.setCanRun(false);
        System.out.println("main里面的----"+myThread.canRun);

    }

    public static class MyThread extends Thread{

        private  boolean canRun = true;

        public boolean isCanRun() {
            return canRun;
        }

        public void setCanRun(boolean canRun) {
            this.canRun = canRun;
        }

        @Override
        public void run() {
            super.run();
            while (canRun) {


            }
            System.out.println("子线程里面的："+canRun);
            System.out.println("子线程终止。。。。");

        }
    }
}
运行结果：

上面例子中，我们的main方法的主线程与子线程MyThread同时对变量canRun变量进行操作，canRun就是多线程的共享数据，通过运行结果可以看出，主线程更改了canRun的值为false，按理说根据循环条件，子线程应该会终止，但是结果并没有终止，而是仍然处在死循环中，可见子线程中的canRun并没有被更改，仍然是true。

为什么会出现这样的问题呢？我们明明已经更改了变量的值啊？下面，我们来看一下这个变量的值是如何的一个存在，和两个线程是如何取值的。




可以看出，多个线程在共享这个数据时，每个线程会自己备份这个数据，并单独进行对数据的操作，这样，线程之间对应这个共享数据时不可见的。


  •     解决办法一：
        当我们用关键字volatile修饰canRun后： 


package com.itszt;
public class Test {
    public static void main(String[] args) throws InterruptedException {

        MyThread myThread = new MyThread();
        System.out.println("开启子线程");
        myThread.start();
        System.out.println("子线程开启完毕");
        Thread.sleep(2000);
        System.out.println("在主线程中终止子线程");
        myThread.setCanRun(false);
        System.out.println("main里面的----"+myThread.canRun);

    }

    public static class MyThread extends Thread{

        private volatile boolean canRun = true;

        public boolean isCanRun() {
            return canRun;
        }

        public void setCanRun(boolean canRun) {
            this.canRun = canRun;
        }

        @Override
        public void run() {
            super.run();
            while (canRun) {


            }
            System.out.println("子线程里面的："+canRun);
            System.out.println("子线程终止。。。。");

        }
    }
}
    运行结果：




  •         解决办法二：
                   使用同步锁sychronized 


package com.itszt;

public class Test {
    public static void main(String[] args) throws InterruptedException {

        MyThread myThread = new MyThread();
        System.out.println("开启子线程");
        myThread.start();
        System.out.println("子线程开启完毕");
        Thread.sleep(2000);
        System.out.println("在主线程中终止子线程");

        myThread.setCanRun(false);
        System.out.println("main里面的----"+myThread.canRun);

    }

    public static class MyThread extends Thread{

        private  boolean canRun = true;

        public boolean isCanRun() {
            return canRun;
        }

        public void setCanRun(boolean canRun) {
            this.canRun = canRun;
        }


        @Override
        public void run() {
            super.run();
            while (true){
                synchronized (Test.class){
                    if (!canRun){
                        break;
                    }
                }
            }
            System.out.println("子线程里面的："+canRun);
            System.out.println("子线程终止。。。。");

        }
    }
}
  运行结果：




三、i++原子性问题

  1.     i++实际分为三步：读取--->修改--->写入
  2.     原子性：“读-改-写”三步为一体的，是不能被拆分的
  3.     原子变量：JDK5以后，java.util.concurrent.atomic包下，提供了常用的原子变量
  •         原子变量的值用volatile修饰，确保变量内存可见性
  •         CAS(Compare-And-Swap)算法保证数据的原子性
下面的例子来看volatile关键字不能确保操作的原子性问题：


 
package com.itszt;

/**
* 
*
*
* 关键字：volatile：保证该数据是被所有子线程共享的
*
* 与static的区别：所有的对象共享同一个数据（volatile是作用于多线程的，static是作用于多对象的）
*
*
*/
public class Test1 {

    private static volatile int i=0;
    private static long timeBegin;

    public static void main(String[] args){
        timeBegin = System.currentTimeMillis();
        for (int a = 0; a < 50; a++) {
            new MyThread().start();
        }
    }
    private static class MyThread extends Thread{
        @Override
        public void run() {
            super.run();
            for (int b = 0; b < 10000; b++) {
                i++;
            }
            System.out.println("最后的值： "+i);
            if (i==500000) {
                System.out.println("结束的时间为："+(System.currentTimeMillis()-timeBegin));
            }
        }
    }
}
运行结果：




可以看出，使用volatile关键字修饰的i，经过50个线程处理，并没有自加到500000，出现这种情况的原因正是因为volatile不能保证操作的原子性，当一个线程读取到当前的i值，在进行读-改-写操作的过程中，已有其他线程更改过了i的值，这样导致更改数据的不一致性。

当我们用原子变量修饰共享数据，就能很好的保证原子性。 


package com.itszt;

import java.util.concurrent.atomic.AtomicInteger;

/**
* 
*
* i++  的原子性   读-改-写
*
* 锁：
*
*      悲观锁：
*
*          我们使用的时候别人是不能用的，只有当我们使用完释放了资源，别人才能用
*          synchronized、lock：可以解决原子性问题，但是运行效率都不高
*
*      乐观锁：
*
*          多个线程可以对同一个数据同时操作，或者同一段代码进行操作，只不过操作结果是否生效就不一定了。
*
*  JUC是如何帮我们解决这个问题的呢？
*
*      JUC基于CAS算法来做
*
*      多个线程对同一个数据进行操作时会留一个版本号，每个线程每操作一次，就会更新版本号，将版本号自增1
*      比如：A操作之前的版本号为0，那么当A操作完之后，A将更改这个版本号为1
*      加入A操作完成之后，在A需要更新版本之前，会检查当前的版本号，发现版本号发生变化不在是0的时候，
*      或者已经为1,那么肯定有另外的线程，比如B对该数据进行了更改，并且生成了新的版本号，此时A就需要重新执行操作了（读改写）
*
*
*
*/
public class Test2 {

    //使用原子变量进行改进
    private static volatile AtomicInteger i = new AtomicInteger(0);
    //声明一个时间戳
    private static long timeBegin;

    public static void main(String[] args){

        timeBegin = System.currentTimeMillis();
        //模拟多线程去操作共享数据i
        for (int b = 0; b < 50; b++) {
            new MyThread().start();
        }
    }

    //定义个线程
    public static class MyThread extends Thread{
        @Override
        public void run() {
            super.run();
            //循环执行i++
            for (int a = 0; a < 10000; a++) {
                i.incrementAndGet();//等同于i++
            }
            System.out.println("输出i的值："+i);
            //计算执行完毕的时间
            if (i.get()==500000) {
                System.out.println("完成时间： "+(System.currentTimeMillis()-timeBegin));
            }
        }
    }
}
运行结果：




解决volatile关键字存在不能保证原子性的不足，另一种解决方案是使用同步锁synchronized，但是执行效率远远不及乐观锁的执行效率


package com.itszt;

/**
* 
*
*
* 关键字：volatile：保证该数据是被所有子线程共享的
*
* 与static的区别：所有的对象共享同一个数据（volatile是作用于多线程的，static是作用于多对象的）
*
*
*/
public class Test1 {

    private static volatile int i=0;

    private static long timeBegin;

    public static void main(String[] args){
        timeBegin = System.currentTimeMillis();
        for (int a = 0; a < 50; a++) {
            new MyThread().start();
        }
    }
    private static class MyThread extends Thread{
        @Override
        public void run() {
            super.run();
            for (int b = 0; b < 10000; b++) {
                //使用同步锁
                synchronized (Test1.class){
                    i++;
                }
            }
            System.out.println("最后的值： "+i);
            if (i==500000) {
                System.out.println("结束的时间为："+(System.currentTimeMillis()-timeBegin));
            }
        }
    }
}
运行结果：

    

四、CAS算法

  •     CAS（Compare-And-Swap）算法是硬件对于并发的支持，针对多处理器操作而设计的处理器中的一种特殊指令，用于管理对共享数据的并发访问；
  •     CAS是一种无锁的非阻塞算法实现
  •     CAS包含三个操作数：
    • 需要读写的内存值：V
    • 进行比较的预估值：A
    • 拟写入的更新值：B
    • 当且仅当V==A时，V=B，否则，将重新操作。
coder_pyy
关注
专栏目录
Java内存模型
诺浅的专栏
07-22 397
什么是Java内存模型 java内存模型(JMM)全称为Java Memory Model，是java虚拟机为了java程序能够正常运行而制定的一套规范，规范中规定了JVM中的数据如何与RAM的数据进行交互。 Java内存模型是怎样的 我们知道，在Java中，实例字段、静态字段和构成数组对象的元素是线程共享的，但局部变量与方法参数是线程私有的，不会被共享。所以以下我们所讲的变量等均指线程共享的数据，而非线程私有的数据。 Java 内存模型中规定了所有的变量都存储在主内存中，每个线程还有自己的工作内存（类比缓
多线程系列(四) -volatile关键字使用详解
程序员志哥的博客
02-20 1062
在上篇文章中，我们介绍到在多线程环境下，如果编程不当，可能会出现程序运行结果混乱的问题。出现这个原因主要是，JMM 中主内存和线程工作内存的数据不一致，以及多个线程执行时无序，共同导致的结果。
JUC篇之volatile关键字（一）
qq_29073117的博客
04-07 187
JUC篇之volatile关键字（一）JUC简介1、内存可见性2、内存可见性错误3、原子性4、volatile关键字验证volatile的内存可见性 JUC简介 1、内存可见性 当多个多个线程对同一变量进行操作的时候，如果其中一个线程对该变量进行了修改操作，可以保证能够被其他线程看到该变量的变化，称之为内存可见性。可以使用volatile保证可见性，也可以用synchronized。 2、内存可见...
JUC之volatile
Lucene/Solr解密
02-06 654
volatile提供了一个高效的同步机制，她在某些情况下可以代替synchronized实现更轻量和高效的同步机制，同时也更为脆弱，更难于掌控。被volatile修饰的变量具有内存可见性，但不具有原子性。至于什么是可见性，前面已经做过简单介绍，接下来我们进一步来看什么是可见性。
JUC之volatile关键字
最新发布
qq_26641137的博客
03-16 483
可见性有序性（禁止指令重排）写指令读指令字节码层面内存屏障是什么？内存屏障： 是一种屏障指令，它使得CPU或者编译器对屏障指令的前和后所发出的内存操作，执行一个排序的约束。也叫内存栅栏或栅栏指令内存屏障能干嘛阻止屏障两边的指令重排序，写数据时加入屏障，强制将线程私有工作内存的数据刷回主物理内存。读数据时加入屏障，线程私有工作内存的数据失效，重新到主物理内存中获取最新数据。内存屏障的四大指令1.在每一个volatile写操作前面插入一个StoreStore屏障。
JUC 常见的关键字
Sun_shine95的博客
04-01 200
原子性 atomic 可见性 volatile、synchronized Volatile、synchronized两者的区别联系 1.volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取；synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。 2.volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的。 3.volatile仅能实现.
多线程——Volatile 关键字详解
qq_42583242的博客
08-22 556
多线程——Volatile 关键字 文章目录多线程——Volatile 关键字一、概念二、Volatile保证可见性三、Volatile禁止指令重排序四、总结 一、概念 在前一篇文章中，我们详细介绍了 Java 内存模型，我们可以发现 Java 内存模型都是围绕着在并发过程中如何处理原子性、可见性和有序性三个特征来建立的，简单回顾一下为什么会产生这三个特性： 原子性：比如一段代码运行在服务器，有一段代码会被所有线程访问，每一个线程都会修改里面的共享变量值，为了保证一个线程在修改的时候，其他的线程不会进来捣
详解Java关键字之 volatile
JavaMonsterr的博客
05-26 687
一、什么是Volatile volatile是Java提供的一种轻量级的同步机制。Java 语言包含两种内在的同步机制：同步块（或方法）和 volatile 变量，相比于synchronized（synchronized通常称为重量级锁），volatile更轻量级，因为它不会引起线程上下文的切换和调度。但是volatile 变量的同步性较差（有时它更简单并且开销更低），而且其使用也更容易出错。 Volatile 可以保证可见性，但不能保证原子性，一种线程同步的机制！很强大来看一道经典面试题~ 请你谈谈
详解volatile关键字和原子引用
weixin_37337210的博客
09-14 691
本篇看一下Volatile关键字和原子引用。 详解volatile关键字和原子引用 上图就是JUC包结构，总共分成三块 （1）java.util.concurrent：并发包基础类，包括阻塞队列，线程池相关类，线程安全Map等。 （2）java.util.concurrent.atomic：原子引用相关类 （3）java.util.concurrent.locks：线程锁相关类 线程池技术在之前的讲解应该很清楚了，今天主要解析一个volatile关键字以及原子引用的相关类。这一篇文件涉及到JMM（java
备战Java面试【面试高频】 -- 详解volatile关键字
Free的午后
07-30 140
1.volatile初步理解 java虚拟机提供的轻量级的同步机制，主要有三个特性： 保证可见性 不保证原子性 禁止指令重排 讲到可见性、原子性这些，我们就不得不提JMM（Java Memory Model）模型，JMM是一种抽象的概念，描述的是一组规则或规范，通过这种规范定义程序各个变量（包括实例字段、静态字段和构成数组的对象的元素）的访问方式。 JMM关于同步的规定： 线程解锁前，必须把共享变量的值刷新回主内存 线程加锁前，必须读取主内存的最新值到自己的工作内存 加锁解锁是同一把锁 由于
（一）JUC 之 volatile 关键字
java_here的博客
09-28 182
  最近项目中用到并发和多线程较多，之前都有所了解，但没有完整的学习，趁此次机会把 java.util.concurrent 包完整的总结学习一遍。 研究juc包，少不了要先研究一下volatile 关键字 和 cas 算法，因为在juc包中很多地方都使用到了volatile 和 cas ，今天先来写volatile。 volatile 关键字之前也或多或少的接触过，之前只了解是为了解决...
操作系统底层认识（并发基础）
dying 搁浅
11-09 2233
在深入了解和掌握并发之前，我们首先得先对我们所使用的操作系统底层的工作原理有一个大概的认识，对于我们后端开发人员来说操作系统中最最重要的两块是 CPU 和 内存。所以后面重点讲解的也在这两块。 冯诺依曼计算机模型 冯诺依曼计算机模型我想大家多多少少都有听过，我们现在的计算机模型都是基于这个发展而来。 计算机在运行时，控制器从内存中读取第一条指令，根据指令的指示去对应的内存中取数据进行相应的运算，将得出的计算结果再写回内存中，然后取出第二条指令同样在控制器的指挥下完成对应的操作，重复以上动作直到遇到停止命令.
JUC —— Volatile
weixin_46540606的博客
02-09 1003
Volatile Volatile是java虚拟机提供的轻量级的同步机制 保证可见性 不保证原子性 禁止指令重排序 什么是JMM JMM：java内存模型，不存在的东西，是一个概念、一个约定 关于JMM的一些同步的约定： 线程解锁前，必须把共享变量立刻刷会主存 线程加锁前，必须读取主存中的最新值到工作内存中 加锁和解锁是同一把锁 线程 工作内存 主内存 JMM八种操作 关于主内存与工作内存之间的交互协议，即一个变量如何从主内存拷贝到工作内存。如何从工作内存同步到主内存中的实现细节。java内存模型
JUC-volatile
江黎
10-07 147
volatile的两大特点： 1、可见性 2、有序性 （不保证原子性） 内存屏障也称内存栅栏，是一类同步屏障指令，是cpu或编译器在对内存随机访问的操作中的一个同步点，使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作，避免代码重排序。内存屏障其实是一种JVM指令，Java内存模型的重排序规则要求Java编译器在生成JVM指令时插入特定的内存屏障指令，通过这些内存屏障指令，volatile实现了Java内存模型中的可见性和有序性，但volatile无法保证原子性。 内存屏障之前的所有写操.
volatile关键字的理解(Java多线程并发)
xiziwen_code
09-25 209
volatile volatile 是一个类型修饰符。volatile 的作用是作为指令关键字，确保本条指令不会因编译器的优化而省略。 volatile 的特性 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。（实现可见性） 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。（实...
JUC详解之Volatile
进击的小白
07-22 255
volatile关键字用于当多个线程进行操作时的数据共享,可以保证内存中的数据是相互可见的，即线程可见性; 功能相似的static关键字则用于实例间的数据共享，是类的静态成员，与线程无关。 相较于synchronized关键字，volatile关键字是较为轻量级的同步策略，不具备互斥性，也不能保证原子性。 public class Volatile { //(1)(2) s...
JUC: 浅析Volatile关键字
weixin_44210395的博客
08-21 318
Volatile关键字         在讲解Volatile关键字关键字之前，我们先来引入一些概念，有助于后续的理解。         JVM（java内存模型）规定：多于多个线程共享的变量，存储在主内存当中，每个线程都有自己独立的工作内存，并且线程只能访问自己的工作内存，不可以访问其他线程的工作内存。    &nbs
JUC并发编程系列详解篇七（volatile关键字详解）
m0_46198325的博客
03-30 1089
java并发编程知识体系详解篇五（volatile关键字详解）
【JUC并发编程】volatile关键字详解
blblccc
07-12 259
关键字: volatile详解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值