博主
258
258
258
258
专辑

第二节 volatile关键字

亮子 2021-10-05 16:43:18 4607 0 0 0

1、volatile的作用

就我理解的而言,被volatile修饰的共享变量,就具有了以下两点特性:

  • 保证了不同线程对该变量操作的内存可见性;
  • 禁止指令重排序

2、内存可见性

这个聊起来可就多了,我还是从Java内存模型说起吧。 Java虚拟机规范试图定义一种Java内存模型(JMM),来屏蔽掉各种硬件和操作系统的内存访问差异,让Java程序在各种平台上都能达到一致的内存访问效果。简单来说,由于CPU执行指令的速度是很快的,但是内存访问的速度就慢了很多,相差的不是一个数量级,所以搞处理器的那群大佬们又在CPU里加了好几层高速缓存。 在Java内存模型里,对上述的优化又进行了一波抽象。JMM规定所有变量都是存在主存中的,类似于上面提到的普通内存,每个线程又包含自己的工作内存,方便理解就可以看成CPU上的寄存器或者高速缓存。所以线程的操作都是以工作内存为主,它们只能访问自己的工作内存,且工作前后都要把值在同步回主内存。 这么说得我自己都有些不清楚了,拿张纸画一下:

可见性

在线程执行时,首先会从主存中read变量值,再load到工作内存中的副本中,然后再传给处理器执行,执行完毕后再给工作内存中的副本赋值,随后工作内存再把值传回给主存,主存中的值才更新。 使用工作内存和主存,虽然加快的速度,但是也带来了一些问题。比如看下面一个例子:

i = i + 1;

假设i初值为0,当只有一个线程执行它时,结果肯定得到1,当两个线程执行时,会得到结果2吗?这倒不一定了。可能存在这种情况:

线程1: load i from 主存    // i = 0
        i + 1  // i = 1
线程2: load i from主存  // 因为线程1还没将i的值写回主存,所以i还是0
        i +  1 //i = 1
线程1:  save i to 主存
线程2: save i to 主存

如果两个线程按照上面的执行流程,那么i最后的值居然是1了。如果最后的写回生效的慢,你再读取i的值,都可能是0,这就是缓存不一致问题。 下面就要提到你刚才问到的问题了,JMM主要就是围绕着如何在并发过程中如何处理原子性可见性有序性这3个特征来建立的,通过解决这三个问题,可以解除缓存不一致的问题。而volatile跟可见性和有序性都有关。

3、并发要处理的三个特性

  • 原子性(Atomicity)

Java中,对基本数据类型的读取和赋值操作是原子性操作,所谓原子性操作就是指这些操作是不可中断的,要做一定做完,要么就没有执行。 比如:

i = 2;
j = i;
i++;
i = i + 1;

上面4个操作中,i=2是读取操作,必定是原子性操作,j=i你以为是原子性操作,其实吧,分为两步,一是读取i的值,然后再赋值给j,这就是2步操作了,称不上原子操作,i++和i = i + 1其实是等效的,读取i的值,加1,再写回主存,那就是3步操作了。所以上面的举例中,最后的值可能出现多种情况,就是因为满足不了原子性。 这么说来,只有简单的读取,赋值是原子操作,还只能是用数字赋值,用变量的话还多了一步读取变量值的操作。有个例外是,虚拟机规范中允许对64位数据类型(long和double),分为2次32为的操作来处理,但是最新JDK实现还是实现了原子操作的。 JMM只实现了基本的原子性,像上面i++那样的操作,必须借助于synchronized和Lock来保证整块代码的原子性了。线程在释放锁之前,必然会把i的值刷回到主存的。

  • 可见性(Visibility)

说到可见性,Java就是利用volatile来提供可见性的。 当一个变量被volatile修饰时,那么对它的修改会立刻刷新到主存,当其它线程需要读取该变量时,会去内存中读取新值。而普通变量则不能保证这一点。 其实通过synchronized和Lock也能够保证可见性,线程在释放锁之前,会把共享变量值都刷回主存,但是synchronized和Lock的开销都更大。

  • 有序性(Ordering)

JMM是允许编译器和处理器对指令重排序的,但是规定了as-if-serial语义,即不管怎么重排序,程序的执行结果不能改变。比如下面的程序段:

double pi = 3.14;    //A
double r = 1;        //B
double s= pi * r * r;//C

上面的语句,可以按照A->B->C执行,结果为3.14,但是也可以按照B->A->C的顺序执行,因为A、B是两句独立的语句,而C则依赖于A、B,所以A、B可以重排序,但是C却不能排到A、B的前面。JMM保证了重排序不会影响到单线程的执行,但是在多线程中却容易出问题。 比如这样的代码:

int a = 0;
bool flag = false;

public void write() {
    a = 2;              //1
    flag = true;        //2
}

public void multiply() {
    if (flag) {         //3
        int ret = a * a;//4
    }
}

假如有两个线程执行上述代码段,线程1先执行write,随后线程2再执行multiply,最后ret的值一定是4吗?结果不一定:

指令重排

如图所示,write方法里的1和2做了重排序,线程1先对flag赋值为true,随后执行到线程2,ret直接计算出结果,再到线程1,这时候a才赋值为2,很明显迟了一步。 这时候可以为flag加上volatile关键字,禁止重排序,可以确保程序的有序性,也可以上重量级的synchronized和Lock来保证有序性,它们能保证那一块区域里的代码都是一次性执行完毕的。

另外,JMM具备一些先天的有序性,即不需要通过任何手段就可以保证的有序性,通常称为happens-before原则。
«JSR-133:Java Memory Model and Thread Specification»定义了如下happens-before规则:
1.程序顺序规则: 一个线程中的每个操作,happens-before于该线程中的任意后续操作
2.监视器锁规则:对一个线程的解锁,happens-before于随后对这个线程的加锁
3.volatile变量规则: 对一个volatile域的写,happens-before于后续对这个volatile域的读
4.传递性:如果A happens-before B ,且 B happens-before C, 那么 A happens-before C
5.start()规则: 如果线程A执行操作ThreadB_start()(启动线程B) , 那么A线程的ThreadB_start()happens-before 于B中的任意操作
6.join()原则: 如果A执行ThreadB.join()并且成功返回,那么线程B中的任意操作happens-before于线程A从ThreadB.join()操作成功返回。
7.interrupt()原则: 对线程interrupt()方法的调用先行发生于被中断线程代码检测到中断事件的发生,可以通过Thread.interrupted()方法检测是否有中断发生
8.finalize()原则:一个对象的初始化完成先行发生于它的finalize()方法的开始

第1条规则程序顺序规则是说在一个线程里,所有的操作都是按顺序的,但是在JMM里其实只要执行结果一样,是允许重排序的,这边的happens-before强调的重点也是单线程执行结果的正确性,但是无法保证多线程也是如此。

第2条规则监视器规则其实也好理解,就是在加锁之前,确定这个锁之前已经被释放了,才能继续加锁。 第3条规则,就适用到所讨论的volatile,如果一个线程先去写一个变量,另外一个线程再去读,那么写入操作一定在读操作之前。 第4条规则,就是happens-before的传递性。 后面几条就不再一一赘述了。

4、volatile底层的实现机制

如果把加入volatile关键字的代码和未加入volatile关键字的代码都生成汇编代码,会发现加入volatile关键字的代码会多出一个lock前缀指令。 lock前缀指令实际相当于一个内存屏障,内存屏障提供了以下功能:
1、重排序时不能把后面的指令重排序到内存屏障之前的位置
2、使得本CPU的Cache写入内存
3、写入动作也会引起别的CPU或者别的内核无效化其Cache,相当于让新写入的值对别的线程可见。

5、用代码证明volatile是非原子性的

package com.shenmazong;

public class DemoThread01 {
    private static int count = 0;

    public static void add() {
        count ++;
    }

    public static void main(String[] args) throws InterruptedException {
        // 创建10个线程
        for (int idx = 0; idx < 10; idx++) {
            // 每个线程累加100次
            new Thread(()->{
                for (int ndx = 0; ndx < 1000; ndx++) {
                    add();
                }
            }).start();
        }

        // 等待所有线程执行完成
        while (Thread.activeCount()>2) {
            Thread.yield();
        }

        // 打印累加结果
        System.out.println("count="+count);
    }
}

通过运行一下命令可以查看add函数的字节码:

javap -c DemoThread01.class

volitile字节码

从以上截图可以看出来,++这个操作不是原子操作,可以使用下面改造,实现数据的同步:

    public static synchronized void add() {
        count ++;
    }

使用原子类实现:

package com.shenmazong;

import java.util.concurrent.atomic.AtomicInteger;

public class DemoThread01 {
    private static AtomicInteger count = new AtomicInteger();

    public static synchronized void add() {
//        count ++;   // 不是原子操作
        count.getAndIncrement();    // +1,使用CAS
    }


    public static void main(String[] args) throws InterruptedException {
        // 创建10个线程
        for (int idx = 0; idx < 10; idx++) {
            // 每个线程累加100次
            new Thread(()->{
                for (int ndx = 0; ndx < 1000; ndx++) {
                    add();
                }
            }).start();
        }

        // 等待所有线程执行完成
        while (Thread.activeCount()>2) {
            Thread.yield();
        }

        // 打印累加结果
        System.out.println("count="+count);
    }
}

参考文章: