在并发编程中,有如下三大特性:
- 可见性:当一条线程修改了变量的值,新值对于其他线程来说是可以立即得知的;
- 有序性:JVM执行代码的顺序跟程序员编写代码的顺序一致;
- 原子性:不可被拆分的操作,例如赋值语句:int i = 1;
对于volatile修饰的变量,我们常说其具有可见性和有序性。在这篇文章中,先抛开这些概念,用代码先简单地对比下,对用volatile修饰和未用volatile修饰的变量进行操作有什么区别
1、对变量只进行读操作
public class VolatileReadTest {
public static final int COUNT = 10000000;
public static volatile int volatileValue = 0 ;
public static int normalValue = 0 ;
public static void main(String[] args) {
readVolatileValue();
readNormalValue();
}
/**
* 对使用volatile关键字修饰的变量进行COUNT次读操作
*/
public static void readVolatileValue() {
long start = System.currentTimeMillis();
for (int i = 0; i < COUNT; i++) {
int temp = volatileValue;
}
System.out.println("readVolatileValue : " + (System.currentTimeMillis() - start));
}
/**
* 对未使用volatile关键字修饰的变量进行COUNT次读操作
*/
public static void readNormalValue() {
long start = System.currentTimeMillis();
for (int i = 0; i < COUNT; i++) {
int temp = normalValue;
}
System.out.println("readNormalValue : " + (System.currentTimeMillis() - start));
}
}
在这段代码中,分别定义了两个变量:一个用volatile修饰、一个未用volatile修饰,然后在for循环中进行同样次数的读取该变量的操作,耗时时间如下:
readVolatileValue : 3ms
readNormalValue : 3ms
可以看出时间相同(就算不相等,差距也很小),所以说只对变量做读操作,volatile相对于普通变量不会做任何特殊的处理。它们访问该变量的逻辑都是:CPU始终都会从Cache中获取该变量,第一次会发生Cache Miss,这时Cache就会从主内存将变量加载进来,后面CPU就能Cache Hit。
2、对变量进行读写操作
public class VolatileReadAndWriteTest {
public static final int COUNT = 10000000;
public static volatile int volatileSum = 0 ;
public static int normalSum = 0 ;
public static void main(String[] args) {
readAndWriteVolatileValue();
readAndWriteNormalValue();
}
/**
* 对使用volatile关键字修饰的变量进行COUNT次读写操作
*/
public static void readAndWriteVolatileValue() {
long start = System.currentTimeMillis();
for (int i = 0; i < COUNT; i++) {
volatileSum++;
}
System.out.println("readAndWriteVolatileValue : " + (System.currentTimeMillis() - start) + "ms");
}
/**
* 对未使用volatile关键字修饰的变量进行COUNT次读写操作
*/
public static void readAndWriteNormalValue() {
long start = System.currentTimeMillis();
for (int i = 0; i < COUNT; i++) {
normalSum++;
}
System.out.println("readAndWriteNormalValue : " + (System.currentTimeMillis() - start) + "ms");
}
}
在这段代码中,与前面代码唯一不同的是,不光对变量进行了读,还进行了写,耗时时间如下:
readAndWriteVolatileValue : 85ms
readAndWriteNormalValue : 4ms
可以看出它们的差距还是很大的,而且该差距跟COUNT的变大成正比。造成这种现象的原因是:在对变量进行写操作时,首先也还是从主内存加载到Cache,再送往CPU进行了递增操作,最后将修改后的值返回到Cache。接下来是关键,用volatile修饰的变量,同时会将修改后的值同步到主内存,而普通变量则不会。正是多次从Cache到主内存的时间,造成了该时间差。
之所以对用volatile修饰的变量进行了写操作后,其值会同步到主内存,就是为了要保证可见性。下面我们再通过一段代码,观察下volatile在多线程中是如何保证可见性的。
3、可见性
public class VolatileVisibilityTest {
public static boolean initFlag = false;
public static void main(String[] args) throws Exception {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("waiting data...");
while (!initFlag) {
}
System.out.println("success");
}
},"A").start();
Thread.sleep(100);
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("prepareing data...");
initFlag = true;
System.out.println("prepare end");
}
},"B").start();
}
}
首先不使用volatile,定义一个变量initFlag=false,在线程A中判断如果该值变为true,就会打印后面的"success",在线程B中将initFlag置为true。理想情况下,我们希望会打印出"success",可实际上打印结果如下:
waiting data...
prepareing data...
prepare end
造成这种现象的原因,是由于线程A和B在使用initFlag时首先会将该false值从主内存分别拷贝到它们的工作内存中,在B中进行了initFlag = true操作后,会将最新值同步到主内存;但是A始终会从其工作内存中读取,读到的始终是false,因此不会执行后面的代码。
现在对initFlag变量进行volatile修饰:
public static volatile boolean initFlag = false;
再次观察打印结果
waiting data...
prepareing data...
prepare end
success
可以看出能正常打印success,这是由于对initFlag进行volatile修饰,在线程B中执行initFlag=true后,在Java内存模型中:
1、B首先发送一个lock指令,将主内存中的initFlag所在的地址加锁。当执行完store和write操作后进行解锁;
2、B将修改后变量的值通过总线更新到主内存时,会发送一个该变量失效的广播。A一直在对总线进行嗅探,当接收到该广播后,将自身工作内存中的该变量置为无效;
3、当A从工作内存中读取该变量时,发现已置为无效,就会从主内存中重新读取;
之所以在将新值通过总线同步到主内存之前有个加锁的操作,因为不加锁可能会出现这种问题:在B执行store和write前,A可能会读取主内存中的值,但这时的值还没有更新过来。
4、i++操作
首先声明,volatile无法保证原子性,如下代码进行验证
public class VolatileAtomicityTest {
public static final int COUNT = 10000;
public static volatile int sum = 0;
public static void increase() {
sum = sum + 1;
}
public static void main(String[] args) throws Exception {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(sum);
}
static class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < COUNT; i++) {
increase();
}
}
}
}
定义一个静态变量sum,新建两个线程,分别进行COUNT次递增操作,实际打印出的结果并不是我们预期的20000,而是小于20000。这是因为sum = sum + 1;不是原子操作,它可以拆分为如下三个原子操作:
1、从主内存将sum的值加载到工作内存,read和load;
2、CPU从工作内存读取该值,use;
3、CPU执行完加1操作后将值更新到工作内存,assign;
问题就出在2和3之间,用volatile修饰的sum,虽然use时能保证工作内存中的值是最新的,但是在assign时别的线程可能修改了最新值并同步到了工作内存,那么此时use的值就过期了,导致某些加1操作的效果丢失。
备注:如下图是CPU访问内存中变量的过程