一、前言
在看JAVA并发包中的源码时,能发现有很多地方使用了volatile关键字声明变量,因此产生了疑问,volatile关键字是什么意思?用它声明的变量与普通的变量有什么不同?这个关键字在什么情况下会用到?带着这些疑问,我查了一些文章和书籍,在此记录一下,希望对大家有所帮助。
二、Volatile变量
《Java并发编程实战》写道:“Java提供了一种稍弱的同步机制,即volatile变量,用来确保将变量的更新操作通知到其他线程。当把变量声明为volatile后,不会将变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存到寄存器或其他处理器不可见的地方,因此在读取时volatile类型的变量总会返回最新写入的值”。
总结起来volatile有一下两个作用:
1、保证多个线程对变量的操作内存可见性。
2、禁止指令重排序。
三、那么什么是内存可见性?什么又是指令重排序呢?
我们先说一下Java内存模型,在Java虚拟机规范中试图定义一种Java内存模型来屏蔽掉各种硬件和操作系统的内存访问差异,让Java程序在各个平台都能达到一致的内存访问效果。简单来说,由于CPU执行指令的速度很快,但内存访问相对很慢,所以人们在CPU中加了好几层的高速缓存。
在Java内存模型里,对上述的优化又做了一波抽象。JMM规定所有变量都是存在主存中的,每个线程包含自己的工作内存,所有线程的操作都是以工作内存为主,他们只能访问自己的工作内存,且工作后还要把值同步回主存。
在线程执行时,会首先从主存中Read变量值,再Load到工作内存副本中再传给处理器执行完毕,执行完毕后再写回工作内存,最后再写回到主存主存中的值才更新。这种方法虽然加快了速度,但也带来了一些问题。如 i = i + 1;假设 i 的初始值为0,在单线程情况下执行i的值回是1,但是在多线程情况下就不一定了。可能执行情况如下:
#线程1 #线程二 1,读取主存中的值0 读取主存中的值0(线程一还没写入) i+1 i+1 2、将结果写入主存 将结果写入主存 此时结果还是1
如果按照上面的执行情况执行,那么得到的结果还是1,这就是缓存不一致问题。
JMM主要就是围绕着如何在并发过程中如何处理原子性、可见性和有序性这3个特征来建立的,通过解决这三个问题,可以解除缓存不一致的问题。而volatile跟可见性和有序性都有关。
四、原子性、可见性、有序性
1、原子性(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
的值刷回到主存的。
2、可见性(Visibility)
Java就是利用volatile来提供可见性的。 当一个变量被volatile修饰时,那么对它的修改会立刻刷新到主存,并且使得其他线程工作线程中的值失效,当其它线程需要读取该变量时,会去内存中读取新值。而普通变量则不能保证这一点。其实通过synchronized和Lock也能够保证可见性,线程在释放锁之前,会把共享变量值都刷回主存,但是synchronized和Lock的开销都更大。
3、有序性(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规则:
- 程序顺序规则: 一个线程中的每个操作,happens-before于该线程中的任意后续操作
- 监视器锁规则:对一个线程的解锁,happens-before于随后对这个线程的加锁
- volatile变量规则: 对一个volatile域的写,happens-before于后续对这个volatile域的读
- 传递性:如果A happens-before B ,且 B happens-before C, 那么 A happens-before C
- start()规则: 如果线程A执行操作
ThreadB_start()
(启动线程B) , 那么A线程的ThreadB_start()
happens-before 于B中的任意操作 - join()原则: 如果A执行
ThreadB.join()
并且成功返回,那么线程B中的任意操作happens-before于线程A从ThreadB.join()
操作成功返回。 - interrupt()原则: 对线程
interrupt()
方法的调用先行发生于被中断线程代码检测到中断事件的发生,可以通过Thread.interrupted()
方法检测是否有中断发生 - finalize()原则:一个对象的初始化完成先行发生于它的
finalize()
方法的开始。
五、Volatile如何满足并发编程的三大特性
对一个volatile域的写,happens-before于后续对这个volatile域的读。 这条再拎出来说,其实就是如果一个变量声明成是volatile的,那么当我读变量时,总是能读到它的最新值,这里最新值是指不管其它哪个线程对该变量做了写操作,都会立刻被更新到主存里,我也能从主存里读到这个刚写入的值。也就是说volatile关键字可以保证可见性以及有序性。
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、2没有重排序。3也不会那么顺利的执行的。假设还是线程1先执行write
操作,线程2再执行multiply
操作,由于线程1是在工作内存里把flag赋值为1,不一定立刻写回主存,所以线程2执行时,multiply
再从主存读flag值,仍然可能为false,那么括号里的语句将不会执行。
如果改成下面这样:
int a = 0; volatile 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
。根据happens-before原则,这个过程会满足以下3类规则:
- 程序顺序规则:1 happens-before 2; 3 happens-before 4; (volatile限制了指令重排序,所以1 在2 之前执行)
- volatile规则:2 happens-before 3
- 传递性规则:1 happens-before 4
当写一个volatile变量时,JMM会把该线程对应的本地内存中的共享变量刷新到主内存。
当读一个volatile变量时,JMM会把该线程对应的本地内存置为无效,线程接下来将从主内存中读取共享变量。
六、Volatile不能保证原子性
Volatile变量不能保证原子性,如下面这个例子:
public class Test { public volatile int inc = 0; public void increase() { inc++; } public static void main(String[] args) { final Test test = new Test(); for(int i=0;i<10;i++){ new Thread(){ public void run() { for(int j=0;j<1000;j++) test.increase(); }; }.start(); } while(Thread.activeCount()>1) //保证前面的线程都执行完 Thread.yield(); System.out.println(test.inc); }
按道理来说结果是10000,但是运行下很可能是个小于10000的值。有人可能会说volatile不是保证了可见性啊,一个线程对inc的修改,另外一个线程应该立刻看到啊!可是这里的操作inc++是个复合操作啊,包括读取inc的值,对其自增,然后再写回主存。假设线程A,读取了inc的值为10,这时候被阻塞了,因为没有对变量进行修改,触发不了volatile规则。线程B此时也读读inc的值,主存里inc的值依旧为10,做自增,然后立刻就被写回主存了,为11。此时又轮到线程A执行,由于工作内存里保存的是10,所以继续做自增,再写回主存,11又被写了一遍。所以虽然两个线程执行了两次increase(),结果却只加了一次。
有人说,volatile不是会使缓存行无效的吗?但是这里线程A读取到线程B也进行操作之前,并没有修改inc值,所以线程B读取的时候,还是读的10。又有人说,线程B将11写回主存,不会把线程A的缓存行设为无效吗?但是线程A的读取操作已经做过了啊,只有在做读取操作时,发现自己缓存行无效,才会去读主存的值,所以这里线程A只能继续做自增了。综上所述,在这种复合操作的情景下,原子性的功能是维持不了了。但是volatile在上面那种设置flag值的例子里,由于对flag的读/写操作都是单步的,所以还是能保证原子性的。要想保证原子性,只能借助于synchronized,Lock以及并发包下的atomic的原子操作类了,即对基本数据类型的 自增(加1操作),自减(减1操作)、以及加法操作(加一个数),减法操作(减一个数)进行了封装,保证这些操作是原子性操作。
七、Volatile的底层实现机制
如果把加入volatile关键字的代码和未加入volatile关键字的代码都生成汇编代码,会发现加入volatile关键字的代码会多出一个lock前缀指令。lock前缀指令实际相当于一个内存屏障,内存屏障提供了以下功能:
1 . 重排序时不能把后面的指令重排序到内存屏障之前的位置
2 . 使得本CPU的Cache写入内存
3 . 写入动作也会引起别的CPU或者别的内核无效化其Cache,相当于让新写入的值对别的线程可见。
八、在哪里会用到Volatile
1、状态标记,如下面的这段代码:这种对变量的读写操作,标记为volatile可以保证修改对线程立刻可见。比synchronized,Lock有一定的效率提升。
int a = 0; volatile bool flag = false; public void write() { a = 2; //1 flag = true; //2 } public void multiply() { if (flag) { //3 int ret = a * a;//4 } }
2、单例模式的实现,典型的双重检查锁定(DCL)
class Singleton{ private volatile static Singleton instance = null; private Singleton() { } public static Singleton getInstance() { if(instance==null) { synchronized (Singleton.class) { if(instance==null) instance = new Singleton(); } } return instance; } }
这是一种懒汉的单例模式,使用时才创建对象,而且为了避免初始化操作的指令重排序,给instance加上了volatile。