Java高并发学习笔记（四）：volatile关键字

时间  2021-05-16
标签 html java 编程 缓存 多线程 架构 并发 app ide 高并发 栏目 Java 繁體版
原文   原文链接

1 来源

  • 来源：《Java高并发编程详解 多线程与架构设计》，汪文君著
  • 章节：第12、十三章

本文是两章的笔记整理。html

2 CPU缓存

2.1 缓存模型

计算机中的全部运算操做都是由CPU完成的，CPU指令执行过程须要涉及数据读取和写入操做，可是CPU只能访问处于内存中的数据，而内存的速度和CPU的速度是远远不对等的，所以就出现了缓存模型，也就是在CPU和内存之间加入了缓存层。通常现代的CPU缓存层分为三级，分别叫L1缓存、L2缓存和L3缓存，简略图以下：java

在这里插入图片描述

  • L1缓存：三级缓存中访问速度最快，可是容量最小，另外L1缓存还被划分红了数据缓存（L1d，data首字母）和指令缓存（L1i，instruction首字母）
  • L2缓存：速度比L1慢，可是容量比L1大，在现代的多核CPU中，L2通常被单个核独占
  • L3缓存：三级缓存中速度最慢，可是容量最大，现代CPU中也有L3是多核共享的设计，好比zen3架构的设计

在这里插入图片描述

缓存的出现，是为了解决CPU直接访问内存效率低下的问题，CPU进行运算的时候，将须要的数据从主存复制一份到缓存中，由于缓存的访问速度快于内存，在计算的时候只须要读取缓存并将结果更新到缓存，运算结束再将结果刷新到主存，这样就大大提升了计算效率，总体交互图简略以下：编程

在这里插入图片描述

2.2 缓存一致性问题

虽然缓存的出现，大大提升了吞吐能力，可是，也引入了一个新的问题，就是缓存不一致。好比，最简单的一个i++操做，须要将内存数据复制一份到缓存中，CPU读取缓存值并进行更新，先写入缓存，运算结束后再将缓存中新的刷新到内存，具体过程以下：缓存

  • 读取内存中的i到缓存中
  • CPU读取缓存i中的值
  • 对i进行加1操做
  • 将结果写回缓存
  • 再将数据刷新到主存

这样的i++操做在单线程不会出现问题，但在多线程中，由于每一个线程都有本身的工做内存（也叫本地内存，是线程本身的缓存），变量i在多个线程的本地内存中都存在一个副本，若是有两个线程执行i++操做：多线程

  • 假设两个线程为A、B，同时假设i初始值为0
  • 线程A从内存中读取i的值放入缓存中，此时i的值为0，线程B也同理，放入缓存中的值也是0
  • 两个线程同时进行自增操做，此时A、B线程的缓存中，i的值都是1
  • 两个线程将i写入主内存，至关于i被两次赋值为1
  • 最终结果是i的值为1

这个就是典型的缓存不一致问题，主流的解决办法有：架构

  • 总线加锁
  • 缓存一致性协议

2.2.1 总线加锁

这是一种悲观的实现方式，具体来讲，就是经过处理器发出lock指令，锁住总线，总线收到指令后，会阻塞其余处理器的请求，直到占用锁的处理器完成操做。特色是只有一个抢到总线锁的处理器运行，可是这种方式效率低下，一旦某个处理器获取到锁其余处理器只能阻塞等待，会影响多核处理器的性能。并发

2.2.2 缓存一致性协议

图示以下：app

在这里插入图片描述

缓存一致性协议中最出名的就是MESI协议，MESI保证了每个缓存中使用的共享变量的副本都是一致的。大体思想是，CPU操做缓存中的数据时，若是发现该变量是一个共享变量，操做以下：ide

  • 读取：不作其余处理，只是将缓存中数据读取到寄存器中
  • 写入：发出信号通知其余CPU将该变量的缓存行设置为无效状态（Invalid），其余CPU进行该变量的读取时须要到主存中再次获取

具体来讲，MESI中规定了缓存行使用4种状态标记：高并发

  • M：Modified，被修改
  • E：Exclusive，独享的
  • S：Shared，共享的
  • I：Invalid，无效的

有关MESI详细的实现超出了本文的范围，想要详细了解能够参考此处或此处。

3 JMM

看完了CPU缓存再来看一下JMM，也就是Java内存模型，指定了JVM如何与计算机的主存进行工做，同时也决定了一个线程对共享变量的写入什么时候对其余线程可见，JMM定义了线程和主内存之间的抽象关系，具体以下：

  • 共享变量存储于主内存中，每一个线程均可以访问
  • 每一个线程都有私有的工做内存或者叫本地内存
  • 工做内存只存储该线程对共享变量的副本
  • 线程不能直接操做主内存，只有先操做了工做内存以后才能写入主内存
  • 工做内存和JMM内存模型同样也是一个抽象概念，其实并不存在，涵盖了缓存、寄存器、编译期优化以及硬件等

简略图以下：

在这里插入图片描述

与MESI相似，若是一个线程修改了共享变量，刷新到主内存后，其余线程读取工做内存的时候发现缓存失效，会从主内存再次读取到工做内存中。

而下图表示了JVM与计算机硬件分配的关系：

在这里插入图片描述

4 并发编程的三个特性

文章都看了大半了还没到volatile？别急别急，先来看看并发编程中的三个重要特性，这对正确理解volatile有很大的帮助。

4.1 原子性

原子性就是在一次或屡次操做中：

  • 要么全部的操做所有都获得了执行，且不会受到任何因素的干扰而中断
  • 要么全部的操做都不执行

一个典型的例子就是两我的转帐，好比A向B转帐1000元，那么这包含两个基本的操做：

  • A的帐户扣除1000元
  • B的帐户增长1000元

这两个操做，要么都成功，要么都失败，也就是不能出现A帐户扣除1000可是B帐户金额不变的状况，也不能出现A帐户金额不变B帐户增长1000的状况。

须要注意的是两个原子性操做结合在一块儿未必是原子性的，好比i++。本质上来讲，i++涉及到了三个操做：

  • get i
  • i+1
  • set i

这三个操做都是原子性的，可是组合在一块儿（i++）就不是原子性的。

4.2 可见性

另外一个重要的特性是可见性，可见性是指，一个线程对共享变量进行了修改，那么另外的线程能够当即看到修改后的最新值。

一个简单的例子以下：

public class Main {
    private int x = 0;
    private static final int MAX = 100000;
    public static void main(String[] args) throws InterruptedException {
        Main m = new Main();
        Thread thread0 = new Thread(()->{
            while(m.x < MAX) {
                ++m.x;
            }
        });

        Thread thread1 = new Thread(()->{
            while(m.x < MAX){
            }
            System.out.println("finish");
        });

        thread1.start();
        TimeUnit.MILLISECONDS.sleep(1);
        thread0.start();
    }
}

线程thread1会一直运行，由于thread1把x读入工做内存后，会一直判断工做内存中的值，因为thread0改变的是thread0工做内存的值，并无对thread1可见，所以永远也不会输出finish，使用jstack也能够看到结果：

在这里插入图片描述

4.3 有序性

有序性是指代码在执行过程当中的前后顺序，因为JVM的优化，致使了代码的编写顺序未必是代码的运行顺序，好比下面的四条语句：

int x = 10;
int y = 0;
x++;
y = 20;

有可能y=20在x++前执行，这就是指令重排序。通常来讲，处理器为了提升程序的效率，可能会对输入的代码指令作必定的优化，不会严格按照编写顺序去执行代码，但能够保证最终运算结果是编码时的指望结果，固然，重排序也有必定的规则，须要严格遵照指令之间的数据依赖关系，并非能够任意重排序，好比：

int x = 10;
int y = 0;
x++;
y = x+1;

y=x+1就不能先优于x++执行。

在单线程下重排序不会致使预期值的改变，但在多线程下，若是有序性得不到保证，那么将可能出现很大的问题：

private boolean initialized = false;
private Context context;
public Context load(){
    if(!initialized){
        context = loadContext();
        initialized = true;
    }
    return context;
}

若是发生了重排序，initialized=true排序到了context=loadContext()的前面，假设两个线程A、B同时访问，且loadContext()须要必定耗时，那么：

  • 线程A经过判断后，先设置布尔变量的值为true，再进行loadContext()操做
  • 线程B中因为布尔变量被设置为true，会直接返回一个未加载完成的context

5 volatile

好了终于到了volatile了，前面说了这么多，目的就是为了能完全理解和明白volatile。这部分分为四个小节：

  • volatile的语义
  • 如何保证有序性以及可见性
  • 实现原理
  • 使用场景
  • 与synchronized区别

先来介绍一下volatile的语义。

5.1 语义

被volatile修饰的实例变量或者类变量具备两层语义：

  • 保证了不一样线程之间对共享变量操做时的可见性
  • 禁止对指令进行重排序操做

5.2 如何保证可见性以及有序性

先说结论：

  • volatile能保证可见性
  • volatile能保证有序性
  • volatile不能保证原子性

下面分别进行介绍。

5.2.1 可见性

Java中保证可见性有以下方式：

  • volatile：当一个变量被volatile修饰时，对共享资源的读操做会直接在主内存中进行（准确来讲也会读取到工做内存中，可是若是其余线程进行了修改就必须从主内存从新读取），写操做是先修改工做内存，可是修改结束后当即刷新到主内存中
  • synchronized：synchronized同样能保证可见性，可以保证同一时刻只有一个线程获取到锁，而后执行同步方法，而且确保锁释放以前，变量的修改被刷新到主内存中
  • 使用显式锁Lock：Lock的lock方法能保证同一时刻只有一个线程可以获取到锁而后执行同步方法，而且确保锁释放以前可以将对变量的修改刷新到主内存中

具体来讲，能够看一下以前的例子：

public class Main {
    private int x = 0;
    private static final int MAX = 100000;
    public static void main(String[] args) throws InterruptedException {
        Main m = new Main();
        Thread thread0 = new Thread(()->{
            while(m.x < MAX) {
                ++m.x;
            }
        });

        Thread thread1 = new Thread(()->{
            while(m.x < MAX){
            }
            System.out.println("finish");
        });

        thread1.start();
        TimeUnit.MILLISECONDS.sleep(1);
        thread0.start();
    }
}

上面说过这段代码会不断运行，一直没有输出，就是由于修改后的x对线程thread1不可见，若是在x的定义中加上了volatile，就不会出现没有输出的状况了，由于此时对x的修改是线程thread1可见的。

5.2.2 有序性

JMM中容许编译期和处理器对指令进行重排序，在多线程的状况下有可能会出现问题，为此，Java一样提供了三种机制去保证有序性：

  • volatile
  • synchronized
  • 显式锁Lock

另外，关于有序性不得不提的就是Happens-before原则。Happends-before原则说的就是若是两个操做的执行次序没法从该原则推导出来，那么就没法保证有序性，JVM或处理器能够任意重排序。这么作的目的是为了尽量提升程序的并行度，具体规则以下：

  • 程序次序规则：在一个线程内，代码按照编写时的次序执行，编写在后面的操做发生与编写在前面的操做以后
  • 锁定规则：若是一个锁处于锁定状态，则unlock操做要先行发生于对同一个锁的lock操做
  • volatile变量规则：对一个变量的写操做要早于对这个变量以后的读操做
  • 传递规则：若是操做A先于操做B，操做B先于操做C，那么操做A先于操做C
  • 线程启动规则：Thread对象的start()方法先行发生于对该线程的任何动做
  • 线程中断规则：对线程执行interrupt()方法确定要优于捕获到中断信号，换句话说，若是收到了中断信号，那么在此以前一定调用了interrupt()
  • 线程终结规则：线程中全部操做都要先行发生于线程的终止检测，也就是逻辑单元的执行确定要发生于线程终止以前
  • 对象终结规则：一个对象初始化的完成先行发生于finalize()以前

对于volatile，会直接禁止对指令重排，可是对于volatile先后无依赖关系的指令能够随意重排，好比：

int x = 0;
int y = 1;
//private volatile int z;
z = 20;
x++;
y--;

在z=20以前，先定义x或先定义y并无要求，只须要在执行z=20的时候，能够保证x=0,y=1便可，同理，x++或y--具体先执行哪个并无要求，只须要保证二者执行在z=20以后便可。

5.2.3 原子性

在Java中，全部对基本数据类型变量的读取赋值操做都是原子性的，对引用类型的变量读取和赋值也是原子性的，可是：

  • 将一个变量赋值给另外一个变量的操做不是原子性的，由于涉及到了一个变量的读取以及一个变量的写入，两个原子性操做结合在一块儿就不是原子性操做
  • 多个原子性操做在一块儿就不是原子性操做，好比i++
  • JMM只保证基本读取和赋值的原子性操做，其余的均不保证，若是须要具有原子性，那么可使用synchronized或Lock，或者JUC包下的原子操做类

也就是说，volatile并不能保证原子性，例子以下：

public class Main {
    private volatile int x = 0;
    private static final CountDownLatch latch = new CountDownLatch(10);

    public void inc() {
        ++x;
    }

    public static void main(String[] args) throws InterruptedException {
        Main m = new Main();
        IntStream.range(0, 10).forEach(i -> {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    m.inc();
                }
                latch.countDown();
            }).start();
        });
        latch.await();
        System.out.println(m.x);
    }
}

最后输出的x的值会少于10000，并且每次运行的结果也并不相同，至于缘由，能够从两个线程A、B开始分析，图示以下：

在这里插入图片描述

  • 0-t1：线程A将x读入工做内存，此时x=0
  • t1-t2：线程A时间片完，CPU调度线程B，线程B将x读入工做内存，此时x=0
  • t2-t3：线程B对工做内存中的x进行自增操做，并更新到工做内存中
  • t3-t4：线程B时间片完，CPU调度线程A，同理线程A对工做内存中的x自增
  • t4-t5：线程A将工做内存中的值写回主内存，此时主内存中的值为x=1
  • t5之后：线程A时间片完，CPU调度线程B，线程B也将本身的工做内存写回主内存，再次将主内存中的x赋值为1

也就是说，多线程操做的话，会出现两次自增可是实际上只进行一次数值修改的操做。想要x的值变为10000也很简单，加上synchronized便可：

new Thread(() -> {
    synchronized (m) {
        for (int j = 0; j < 1000; j++) {
            m.inc();
        }
    }
    latch.countDown();
}).start();

5.3 实现原理

前面已经知道，volatile能够保证有序性以及可见性，那么，具体是如何操做的呢？

答案就是一个lock;前缀，该前缀实际上至关于一个内存屏障，该内存屏障会为指令的执行提供以下几个保障：

  • 确保指令重排序时不会将其后面的代码排到内存屏障以前
  • 确保指令重排序时不会将其前面的代码排到内存屏障以后
  • 确保执行到内存屏障修饰的指令时前面的代码所有执行完成
  • 强制将线程工做内存中的值修改刷新到主存中
  • 若是是写操做，会致使其余线程工做内存中的缓存数据失效

5.4 使用场景

一个典型的使用场景是利用开关进行线程的关闭操做，例子以下：

public class ThreadTest extends Thread{
    private volatile boolean started = true;

    @Override
    public void run() {
        while (started){
            
        }
    }

    public void shutdown(){
        this.started = false;
    }
}

若是布尔变量没有被volatile修饰，那么极可能新的布尔值刷新不到主内存中，致使线程不会结束。

5.5 与synchronized的区别

  • 使用上的区别：volatile只能用于修饰实例变量或者类变量，可是不能用于修饰方法、方法参数、局部变量等，另外能够修饰的变量为null。但synchronized不能用于对变量的修饰，只能修饰方法或语句块，并且monitor对象不能为null
  • 对原子性的保证：volatile没法保证原子性，可是synchronized能够保证
  • 对可见性的保证：volatile与synchronized都能保证可见性，可是synchronized是借助于JVM指令monitor enter/monitor exit保证的，在monitor exit的时候全部共享资源都被刷新到主内存中，而volatile是经过lock;机器指令实现的，迫使其余线程工做内存失效，须要到主内存加载
  • 对有序性的保证：volatile可以禁止JVM以及处理器对其进行重排序，而synchronized保证的有序性是经过程序串行化执行换来的，而且在synchronized代码块中的代码也会发生指令重排的状况
  • 其余区别：volatile不会使线程陷入阻塞，但synchronized会
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程