Java基础:volatile详解

  • 1、volatile保证可见性
    • 1.1、什么是JMM模型?
    • 1.2、volatile保证可见性的代码验证
      • 1.2.1、无可见性代码验证
      • 1.2.1、volatile保证可见性验证
  • 2、volatile不保证原子性
    • 2.1 什么是原子性?
    • 2.2 不保证原子性的代码验证
    • 2.3 volatile不保证原子性的解决方法
      • 2.3.1 方法1:使用synchronized
      • 2.3.2 方法1:使用JUC包下的AtomicInteger
  • 3、volatile禁止指令重排
    • 3.1 什么是指令重排?
    • 3.2 单线程单例模式
    • 3.3 多线程单例模式
    • 3.4 多线程单例模式改进:DCL
    • 3.5 多线程单例模式改进,DCL版存在的问题
    • 3.6 volatile保证禁止指令重排的原理

问:请谈谈你对volatile的理解?
答:volatile是Java虚拟机提供的轻量级的同步机制,它有3个特性:
1)保证可见性
2)不保证原子性
3)禁止指令重排

刚学完java基础,如果有人问你什么是volatile?它有什么作用的话,相信一定非常懵逼…
可能看了答案,也完全不明白,什么是同步机制?什么是可见性?什么是原子性?什么是指令重排?

1、volatile保证可见性

1.1、什么是JMM模型?

要想理解什么是可见性,首先要先理解JMM。

JMM(Java内存模型,Java Memory Model)本身是一种抽象的概念,并不真实存在。它描述的是一组规则或规范,通过这组规范,定了程序中各个变量的访问方法。JMM关于同步的规定:
1)线程解锁前,必须把共享变量的值刷新回主内存;
2)线程加锁前,必须读取主内存的最新值到自己的工作内存;
3)加锁解锁是同一把锁;

由于JVM运行程序的实体是线程,创建每个线程时,JMM会为其创建一个工作内存(有些地方称为栈空间),工作内存是每个线程的私有数据区域。

Java内存模型规定所有变量都存储在主内存,主内存是共享内存区域,所有线程都可以访问。

但线程对变量的操作(读取、赋值等)必须在工作内存中进行。因此首先要将变量从主内存拷贝到自己的工作内存,然后对变量进行操作,操作完成后再将变量写会主内存中。

看了上面对JMM的介绍,可能还是优点懵,接下来用一个卖票系统来进行举例:

1)如下图,此时卖票系统后端只剩下1张票,并已读入主内存中:ticketNum=1。
2)此时网络上有多个用户都在抢票,那么此时就有多个线程同时都在进行买票服务,假设此时有3个线程都读入了目前的票数:ticketNum=1,那么接着就会买票。
3)假设线程1先抢占到cpu的资源,先买好票,并在自己的工作内存中将ticketNum的值改为0:ticketNum=0,然后再写回到主内存中。

此时,线程1的用户已经买到票了,那么线程2,线程3此时应该不能再继续买票了,因此需要系统通知线程2,线程3,ticketNum此时已经等于0了:ticketNum=0。如果有这样的通知操作,你就可以理解为就具有可见性。

通过上面对JMM的介绍和举例,可以简单总结下。

JMM内存模型的可见性是指,多线程访问主内存的某一个资源时,如果某一个线程在自己的工作内存中修改了该资源,并写回主内存,那么JMM内存模型应该要通知其他线程来从新获取最新的资源,来保证最新资源的可见性。

1.2、volatile保证可见性的代码验证

在1.1中,已经基本理解了可见性的含义,接下来用代码来验证一下,volatile确实可以保证可见性。

1.2.1、无可见性代码验证

首先先验证下,不使用volatile,是不是就是没有可见性。

package com.koping.test;import java.util.concurrent.TimeUnit;class MyData
{int number = 0;public void add10() {this.number += 10;}
}public class VolatileVisibilityDemo {public static void main(String[] args) {MyData myData = new MyData();// 启动一个线程修改myData的number,将number的值加10new Thread(() -> {System.out.println("线程" + Thread.currentThread().getName()+"\t 正在执行");try{TimeUnit.SECONDS.sleep(3);} catch (Exception e) {e.printStackTrace();}myData.add10();System.out.println("线程" + Thread.currentThread().getName()+"\t 更新后,number的值为" + myData.number);}).start();// 看一下主线程能否保持可见性while (myData.number == 0) {// 当上面的线程将number加10后,如果有可见性的话,那么就会跳出循环;// 如果没有可见性的话,就会一直在循环里执行}System.out.println("具有可见性!");}
}

运行结果如下图,可以看到虽然线程0已经将number的值改为了10,但是主线程还是在循环中,因为此时number不具有可见性,系统不会主动通知。

1.2.1、volatile保证可见性验证

在上面代码的第7行给变量number添加volatile后再次测试,如下图,此时主线程成功退出了循环,因为JMM主动通知了主线程更新number的值了,number已经不为0了。

2、volatile不保证原子性

2.1 什么是原子性?

理解了上面说的可见性之后,再来理解下什么叫原子性?

原子性是指不可分隔,完整性,即某个线程正在做某个业务时,中间不能被分割。要么同时成功,要么同时失败。

还是有点抽象,接下来举个例子。

如下图,创建了一个测试原子性的类:TestPragma。在add方法中将n加1,通过查看编译后的代码可以看到,n++被拆分为3个指令进行执行。

因此可能存在线程1正在执行第1个指令,紧接着线程2也正在执行第1个指令,这样当线程1和线程2都执行完3个指令之后,很容易理解,此时n的值只加了1,而实际是有2个线程加了2次,因此这种情况就是不保证原子性。

2.2 不保证原子性的代码验证

在2.1中已经进行了举例,可能存在2个线程执行n++的操作,但是最终n的值却只加了1的情况,接下来对这种情况再用代码进行演示下。

首先给MyData类添加一个add方法

package com.koping.test;class MyData {volatile int number = 0;public void add() {number++;}
}

然后创建测试原子性的类:TestPragmaDemo。测试下20个线程给number各加1000次之后,number的值是否是20000。

package com.koping.test;public class TestPragmaDemo {public static void main(String[] args) {MyData myData = new MyData();// 启动20个线程,每个线程将myData的number值加1000次,那么理论上number值最终是20000for (int i=0; i<20; i++) {new Thread(() -> {for (int j=0; j<1000; j++) {myData.add();}}).start();}// 程序运行时,模型会有主线程和守护线程。如果超过2个,那就说明上面的20个线程还有没执行完的,就需要等待while (Thread.activeCount()>2){Thread.yield();}System.out.println("number值加了20000次,此时number的实际值是:" + myData.number);}
}

运行结果如下图,最终number的值仅为18410。
可以看到即使加了volatile,依然不保证有原子性。

2.3 volatile不保证原子性的解决方法

上面介绍并证明了volatile不保证原子性,那如果希望保证原子性,怎么办呢?以下提供了2种方法

2.3.1 方法1:使用synchronized

方法1是在add方法上添加synchronized,这样每次只有1个线程能执行add方法。

结果如下图,最终确实可以使number的值为20000,保证了原子性。

但是,实际业务逻辑方法中不可能只有只有number++这1行代码,上面可能还有n行代码逻辑。现在为了保证number的值是20000,就把整个方法都加锁了(其实另外那n行代码,完全可以由多线程同时执行的)。所以就优点杀鸡用牛刀,高射炮打蚊子,小题大做了。

package com.koping.test;class MyData {volatile int number = 0;public synchronized void add() {// 在n++上面可能还有n行代码进行逻辑处理number++;}
}

2.3.2 方法1:使用JUC包下的AtomicInteger

给MyData新曾一个原子整型类型的变量num,初始值为0。

package com.koping.test;import java.util.concurrent.atomic.AtomicInteger;class MyData {volatile int number = 0;volatile AtomicInteger num = new AtomicInteger();public void add() {// 在n++上面可能还有n行代码进行逻辑处理number++;num.getAndIncrement();}
}

让num也同步加20000次。结果如下图,可以看到,使用原子整型的num可以保证原子性,也就是number++的时候不会被抢断。

package com.koping.test;public class TestPragmaDemo {public static void main(String[] args) {MyData myData = new MyData();// 启动20个线程,每个线程将myData的number值加1000次,那么理论上number值最终是20000for (int i=0; i<20; i++) {new Thread(() -> {for (int j=0; j<1000; j++) {myData.add();}}).start();}// 程序运行时,模型会有主线程和守护线程。如果超过2个,那就说明上面的20个线程还有没执行完的,就需要等待while (Thread.activeCount()>2){Thread.yield();}System.out.println("number值加了20000次,此时number的实际值是:" + myData.number);System.out.println("num值加了20000次,此时number的实际值是:" + myData.num);}
}

3、volatile禁止指令重排

3.1 什么是指令重排?

在第2节中理解了什么是原子性,现在要理解下什么是指令重排?

计算机在执行程序时,为了提高性能,编译器和处理器常常会对指令进行重排:
源代码–>编译器优化重排–>指令并行重排–>内存系统重排–>最终执行指令

处理器在进行重排时,必须要考虑指令之间的数据依赖性。

单线程环境中,可以确保最终执行结果和代码顺序执行的结果一致。

但是多线程环境中,线程交替执行,由于编译器优化重排的存在,两个线程使用的变量能否保持一致性是无法确定的,结果无法预测

看了上面的文字性表达,然后看一个很简单的例子。
比如下面的mySort方法,在系统指令重排后,可能存在以下3种语句的执行情况:
1)1234
2)2134
3)1324
以上这3种重排结果,对最后程序的结果都不会有影响,也考虑了指令之间的数据依赖性。

public void mySort() {int x = 1;  // 语句1int y = 2;  // 语句2x = x + 3;  // 语句3y = x * x;  // 语句4
}

3.2 单线程单例模式

看完指令重排的简单介绍后,然后来看下单例模式的代码。

package com.koping.test;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("单线程的情况测试开始");System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());System.out.println("单线程的情况测试结束\n");}
}

首先是在单线程情况下进行测试,结果如下图。可以看到,构造方法只执行了一次,是没有问题的。

3.3 多线程单例模式

接下来在多线程情况下进行测试,代码如下。

package com.koping.test;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();}// DCL(Double Check Lock双端检索机制)
//        if (instance == null) {//            synchronized (SingletonDemo.class) {//                if (instance == null) {//                    instance = new SingletonDemo();
//                }
//            }
//        }return instance;}public static void main(String[] args) {// 单线程测试
//        System.out.println("单线程的情况测试开始");
//        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
//        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
//        System.out.println("单线程的情况测试结束\n");// 多线程测试System.out.println("多线程的情况测试开始");for (int i=1; i<=10; i++) {new Thread(() -> {SingletonDemo.getInstance();}, String.valueOf(i)).start();}}
}

在多线程情况下的运行结果如下图。可以看到,多线程情况下,出现了构造方法执行了2次的情况。

3.4 多线程单例模式改进:DCL

在3.3中的多线程单里模式下,构造方法执行了两次,因此需要进行改进,这里使用双端检锁机制:Double Check Lock, DCL。即加锁之前和之后都进行检查。

package com.koping.test;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();
//        }// DCL(Double Check Lock双端检锁机制)if (instance == null) {  // a行synchronized (SingletonDemo.class) {if (instance == null) {  // b行instance = new SingletonDemo();  // c行}}}return instance;}public static void main(String[] args) {// 单线程测试
//        System.out.println("单线程的情况测试开始");
//        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
//        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
//        System.out.println("单线程的情况测试结束\n");// 多线程测试System.out.println("多线程的情况测试开始");for (int i=1; i<=10; i++) {new Thread(() -> {SingletonDemo.getInstance();}, String.valueOf(i)).start();}}
}

在多次运行后,可以看到,在多线程情况下,此时构造方法也只执行1次了。

3.5 多线程单例模式改进,DCL版存在的问题

需要注意的是3.4中的DCL版的单例模式依然不是100%准确的!!!

是不是不太明白为什么3.4DCL版单例模式不是100%准确的原因
是不是不太明白在3.1讲完指令重排的简单理解后,为什么突然要讲多线程的单例模式

因为3.4DCL版单例模式可能会由于指令重排而导致问题,虽然该问题出现的可能性可能是千万分之一,但是该代码依然不是100%准确的。如果要保证100%准确,那么需要添加volatile关键字,添加volatile可以禁止指令重排

接下来分析下,为什么3.4DCL版单例模式不是100%准确?

查看instance = new SingletonDemo();编译后的指令,可以分为以下3步:
1)分配对象内存空间:memory = allocate();
2)初始化对象:instance(memory);
3)设置instance指向分配的内存地址:instance = memory;

由于步骤2和步骤3不存在数据依赖关系,因此可能出现执行132步骤的情况。
比如线程1执行了步骤13,还没有执行步骤2,此时instance!=null,但是对象还没有初始化完成;
如果此时线程2抢占到cpu,然后发现instance!=null,然后直接返回使用,就会发现instance为空,就会出现异常。

这就是指令重排可能导致的问题,因此要想保证程序100%正确就需要加volatile禁止指令重排。

3.6 volatile保证禁止指令重排的原理

在3.1中简单介绍了下执行重排的含义,然后通过3.2-3.5,借助单例模式来举例说明多线程情况下,为什么要使用volatile的原因,因为可能存在指令重排导致程序异常。

接下来就介绍下volatile能保证禁止指令重排的原理。

首先要了解一个概念:内存屏障(Memory Barrier),又称为内存栅栏。它是一个CPU指令,有2个作用:
1)保证特定操作的执行顺序;
2)保证某些变量的内存可见性;

由于编译器和处理器都能执行指令重排。如果在指令之间插入一条Memory Barrier则会告诉编译器和CPU,不管什么指令都不能和这条Memory Barrier指令重排序,也就是说,通过插入内存屏障,禁止在内存屏障前后的指令执行重排需优化

内存屏障的另一个作用是强制刷出各种CPU的缓存数据,因此任何CPU上的线程都能读取到这些数据的最新版本

Java基础:volatile详解相关推荐

  1. java基础(十三)-----详解内部类——Java高级开发必须懂的

    java基础(十三)-----详解内部类--Java高级开发必须懂的 目录 为什么要使用内部类 内部类基础 静态内部类 成员内部类 成员内部类的对象创建 继承成员内部类 局部内部类 推荐博客 匿名内部 ...

  2. Java基础——匿名内部类详解及举例

    Java基础--匿名内部类详解及举例 说明:定义在外部类的局部位置,比如方法中,并且没有类名 匿名内部类的使用 匿名内部类的基本语法 new 类或接口(参数列表){类体 }; 用途:有些时候为了简化开 ...

  3. Java基础:详解static关键字与类加载顺序

    1. 前言 前文中说到了static关键字,在Java中这是一个很重要的关键字,它有很多的用法,并且在某些特定的情况下使用可以优化程序的性能.本文学习static关键字的应用场景.在这之前了解变量的类 ...

  4. JAVA基础——异常详解

    阅读目录 一.异常简介 二.try-catch-finally语句 三.throw和throws关键字 四.java中的异常链 五.结束语 JAVA异常与异常处理详解 回到顶部 一.异常简介 什么是异 ...

  5. Java基础知识详解

    一.基础 1.Java都有哪些数据类型?基本数据类型有哪些?分别占多少字节?多少位?引用数据类型又有哪些? Java的数据类型:基本数据类型和引用数据类型 基本数据类型:byte(1),short(2 ...

  6. Java基础--awt详解以及简单应用

    GUI 图形用户界面 CLI 命令行用户接口 Java为GUI提供的对象存在java.Awt和Javax.Swing两个包中. Java当中如何完成图形化界面的制作呢? AWT:abstract Wi ...

  7. Java基础——IO详解

    文章目录 前言 一.IO概述 1.IO体系图 2.IO概念及基本操作 二.IO--字节流 InputStream(字节输入流) 1.FileInputStream 2.BuffedInputStrea ...

  8. Java基础---内部类详解

    内部类 概念:定义在类内部的类,可以在类中方法外,也可以在类中方法中根据定义位置的不同,分为成员内部类和局部内部类成员内部类又划分为: 普通的成员内部类 静态的成员内部类 私有的成员内部类另外还有匿名 ...

  9. Java基础---继承详解--this/supper---方法的重写与重载

    继承 语法:子类 extends 父类 java中如果要定义两个类的继承关系,一定要满足里氏代换原则. 子类:用于继承的类,也称为派生类 父类:被继承的类,也称为超类.基类 特点:1.子类可以拥有父类 ...

  10. Java基础----多线程详解

    一.简介 1.什么是线程? 要解释线程,就必须明白什么是进程. 2.什么是进程呢? 进程是指运行中的应用程序,每个进程都有自己独立的地址空间(内存空间),比如用户点击桌面的IE浏览器,就启动了一个进程 ...

最新文章

  1. 8 场 5 胜,微服务 VS 单体架构
  2. WINDOWS SERVER 2003从入门到精通之“域控制器安全策略”打开错误的解决方法
  3. hdu 1788 Chinese remainder theorem again 【crt的具体过程】
  4. RS485 串口调试如何操作
  5. 涨姿势!北京地铁原来是16条旅游专线
  6. pytorch已经安装成功了为什么不能使用import_使用auto keras的过程
  7. 【02】CC - 有意义的命名
  8. elasticsearch date_MySQL数据实时增量同步到Elasticsearch
  9. jQuery实现的向下推送图文信息滚动效果
  10. c#设计模式-适配器模式
  11. 编写高效且优雅的 Python 代码
  12. c++ websocket 客户端
  13. 二建公路工程知识总结_2020二建公路实务:专题突破+高分攻略,拿分90稳过二建...
  14. 火山PC_数据库知识_MySQL操作
  15. oracle材料成本发票价差,ORACLE ERP 成本核算会计信息归纳
  16. Java集成Outlook邮件操作
  17. Incorrect argument type to variable ‘max_allowed_packet‘解决方法
  18. 网络延迟到底是什么东西?
  19. 计算机毕业设计ssm基于web的社团管理系统r848z系统+程序+源码+lw+远程部署
  20. 远程监控tomcat运行

热门文章

  1. eviews做回归分析时输出值的理解
  2. Linux系统盘满了,如何解决。
  3. 计算机口令管理工具,PC免费密码管理器软件推荐
  4. OPENCV计算机视觉图像处理频域傅里叶 DFT 变换低通滤波逆变换IDFT
  5. 高能手办团显示服务器,高能手办团下架了 游戏下架原因介绍[多图]
  6. 再来!使用frida框架hook来获取APP的加密算法的参数
  7. 苹果编程语言Swift解析:将推动应用开发巨变
  8. 自己封装的数据库DbUtils的万能模板
  9. 在经历了6个月的学习后,我终于上架了自己的第一款APP---酷课堂iOS群问答精华整理(201807期)
  10. Linux云计算架构-设置计划任务与管理日志