你应该知道的volatile

2018-02-27 11:45:38来源:https://www.jianshu.com/p/0ae7aad00ed6作者:f_double人点击

分享


volatile的作用归结起来有两点:


1、保证内存可见性
2、防止指令重排序

但是要注意一点


保证double,float的读写的原子性,但是无法保证复合操作的原子性

分别解释:


一、 保证内存可见性


image

CPU和物理内存之间的通信速度远慢于CPU的处理速度,为了提高处理速度,处理器不直接和内存进行通信,而是先将系统内存的数据读到内部缓存(L1,L2或其他)后再进行操作,但操作完不知道何时会写到主内存。


在多线程的情况下就会出现“缓存一致性”问题。


/**
*
* @author fukailong
*
*/
public class Test {
private boolean flag = false;
public void doSomethind() {
while (!flag) {
// System.out.println("执行中..");//这个位置不要打印,因为打印容易触发将线程工作内存中的变量回刷到主存中
}
System.out.println("结束了..");
}
public static void main(String[] args) throws Exception {
final Test sharedObject = new Test();
for (int i = 0; i < 3; i++) {
new Thread() {
public void run() {
sharedObject.doSomethind();
};
}.start();
}
Thread.sleep(100);
new Thread() {
public void run() {
sharedObject.flag = true;
};
}.start();
}
}



未加volatile,会出现缓存一致性问题

大部分情况下线程主函数会结束并打印三个“结束了...”,因为现在的jvm其实已经实现了缓存一致性协议,也就是说当后面的线程修改了flag共享变量后,系统会尽可能将线程工作内存中的变量回刷到主存中。但这只是尽量,这就造成了某个线程会一直执行循环体,也就是你看到的打印了两个“结束了...”。


如果对声明了volatile的变量进行写操作,JVM就会向处理器发送一条Lock前缀的指令,将这个变量所在缓存行的数据写回到系统内存。一个处理器的缓存回写到内存会导致其他处理器的缓存无效,线程接下来将从主内存中读取共享变量。这样就可以保证线程能读取到其他修改的变量值。
增加volatile后效果如下:


/**
*
* @author fukailong
*
*/
public class Test {
private volatile boolean flag = false;
public void doSomethind() {
while (!flag) {
// System.out.println("执行中..");//这个位置不要打印,因为打印容易触发将线程工作内存中的变量回刷到主存中
}
System.out.println("结束了..");
}
public static void main(String[] args) throws Exception {
final Test sharedObject = new Test();
for (int i = 0; i < 3; i++) {
new Thread() {
public void run() {
sharedObject.doSomethind();
};
}.start();
}
Thread.sleep(100);
new Thread() {
public void run() {
sharedObject.flag = true;
};
}.start();
}
}



加了volatile,避免出现缓存一致性问题
二、 防止指令重排序

指令重排序是JVM为了优化指令,提高程序运行效率,在不影响单线程程序执行结果的前提下,尽可能地提高并行度。编译器、处理器也遵循这样一个目标。
在每个volatile写操作的前面插入一个StoreStore屏障。
·在每个volatile写操作的后面插入一个StoreLoad屏障。
·在每个volatile读操作的后面插入一个LoadLoad屏障。
·在每个volatile读操作的后面插入一个LoadStore屏障。


public class Singleton {
private static volatile Singleton singleton;
private Singleton() {
}
public static Singleton getsingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}

以上是懒汉式单例的写法:
如果不加volatile,代码中 singleton = new Singleton()这句,这并非是一个原子操作,事实上在JVM中这句话大概做了下面3件事情
1.给singleton分配内存
2.调用Singleton的构造函数来初始化成员变量
3.将singleton对象指向分配的内存空间(执行到这一步,singleton才是非null的了)
但是在JVM的及时编译器中,存在指令重排序的优化,也就是说,第二步和第三步的顺序是无法保证的 从而导致程序出错。所以需要添加volatile来避免指令重排序。


三、 无法保证原子性
public class Test {
volatile static int a = 0;
private static CountDownLatch countDownLatch;
public static void main(String[] args) throws InterruptedException {
countDownLatch = new CountDownLatch(10000);
for (int i = 0; i < 10000; i++) {
new Thread() {
public void run() {
a++;
countDownLatch.countDown();
}
}.start();
}
countDownLatch.await();
System.out.println(a);
}
}

代码打印的值不一定是10000,可能会是小于10000的值。





image.png

虽然变量a 设置了volatile,但是不能保证a++的操作的原子性,a++包括:读-写-改 的复合操作还是没有变化。


所以volatile不能保证原子性,但用volatile修饰long和double可以保证其操作原子性。





https://docs.oracle.com/javase/specs/jls/se7/html/jls-17.html#jls-17.7

从Oracle Java Spec里面可以看到:


1.对于64位的long和double,如果没有被volatile修饰,那么对其操作可以不是原子的。在操作的时候,可以分成两步,每次对32位操作。
2.如果使用volatile修饰long和double,那么其读写都是原子操作
3.对于64位的引用地址的读写,都是原子操作
4.在实现JVM时,可以自由选择是否把读写long和double作为原子操作


我是double,坐标魔都,QQ群:692595133
如果读完觉得有收获的话,欢迎点赞加关注。

github博客: https://fukailong.github.io
版权归作者所有,转载请联系作者获得授权。




公众号欢迎关注







最新文章

123

最新摄影

闪念基因

微信扫一扫

第七城市微信公众平台