java volatile关键字做用及使用场景

 

1. volatile关键字的做用：保证了变量的可见性（visibility）。被volatile关键字修饰的变量，若是值发生了变动，其余线程立马可见，避免出现脏读的现象。如如下代码片断，isShutDown被置为true后，doWork方法仍有执行。如用volatile修饰isShutDown变量，可避免此问题。

 1 public class VolatileTest3 {
 2     static class Work {
 3         boolean isShutDown = false;
 4 
 5         void shutdown() {
 6             isShutDown = true;
 7             System.out.println("shutdown!");
 8         }
 9 
10         void doWork() {
11             while (!isShutDown) {
12                 System.out.println("doWork");
13             }
14         }
15     }
16 
17     public static void main(String[] args) {
18         Work work = new Work();
19 
20         new Thread(work::doWork).start();
21         new Thread(work::doWork).start();
22         new Thread(work::doWork).start();
23         new Thread(work::shutdown).start();
24         new Thread(work::doWork).start();
25         new Thread(work::doWork).start();
26         new Thread(work::doWork).start();
27     }
28 }

出现脏读时，运行结果以下：

2. 为何会出现脏读？

Java内存模型规定全部的变量都是存在主存当中，每一个线程都有本身的工做内存。线程对变量的全部操做都必须在工做内存中进行，而不能直接对主存进行操做。而且每一个线程不能访问其余线程的工做内存。变量的值什么时候从线程的工做内存写回主存，没法肯定。

3. happens-before规则的理解与勘误

在网上查volatile关键字相关信息时，多篇博客提到了happens-before原则，我的对此原则的理解是：当操做该volatile变量时，全部前序对该变量的操做都已完成（如不存在已变动，但未写回主存的状况），全部后续对该变量的操做，都未开始。仅此而已。

这里，我认为网上很常见的一个理论对此理解有误，以下图。此观点认为，因为volatile变量flag的happens-before原则，因此A线程2处对其的写操做必定先于B线程3处对其的读操做。其实这种观点是有逻辑缺陷的，若是存在一个C线程，先读取flag的值，后写入flag的值，那C线程的执行时机是什么呢？若是还有其余D、E线程呢。。。对于这段代码的正确理解是，只要3处拿到的flag是true，那么a的值必定是1，而不是0.由于volition修饰的变量，处理器不会对其进行重排序，因此1处对a的赋值，必定发生在2处对flag的赋值以前。若是flag不是volatile变量，那么1处和2处代码的执行顺序是没法保证的（处理器的指令重排序），虽然大部分状况1会先于2执行。happens-before原则约束的并非多线程对同一变量的读和写操做之间的顺序，而是保证读操做时，前序全部对该变量的写操做已生效（写回主存）。

 

 

验证以下：

 1 public class VolatileTest {
 2     static class A {
 3         int a = 0;
 4         volatile boolean flag = false;
 5 
 6         void writer() {
 7             a = 1;                   //1
 8             flag = true;               //2
 9             System.out.println("write");
10         }
11 
12         void reader() {
13             if (flag) {                //3
14                 int i =  a;           //4
15                 System.out.println("read true");
16                 System.out.println("i is :" + i);
17             } else {
18                 int i = a;
19                 System.out.println("read false");
20                 System.out.println("i is :" + i);
21             }
22         }
23 
24     }
25 
26     public static void main(String[] args) {
27         A aaa = new A();
28         new Thread(() -> aaa.reader()).start();
29         new Thread(() -> aaa.writer()).start();
30     }
31 }

运行结果以下，在写操做执行以前，读操做已完成

 

 4. volatile关键字使用场景

注意：volatile只能保证变量的可见性，不能保证对volatile变量操做的原子性，见以下代码：

 

 1 public class VolatileTest2 {
 2     static class A {
 3         volatile int a = 0;
 4         void increase() {
 5             a++;
 6         }
 7         int getA(){
 8             return a;
 9         }
10     }
11 
12     public static void main(String[] args) {
13         A a = new A();
14 
15         new Thread(() -> {
16             for (int i = 0;i < 1000;i++) {
17                 a.increase();
18             }
19             System.out.println(a.getA());
20         }).start();
21         new Thread(() -> {
22             for (int i = 0;i < 2000;i++) {
23                 a.increase();
24             }
25             System.out.println(a.getA());
26         }).start();
27         new Thread(() -> {
28             for (int i = 0;i < 3000;i++) {
29                 a.increase();
30             }
31             System.out.println(a.getA());
32         }).start();
33         new Thread(() -> {
34             for (int i = 0;i < 4000;i++) {
35                 a.increase();
36             }
37             System.out.println(a.getA());
38         }).start();
39         new Thread(() -> {
40             for (int i = 0;i < 5000;i++) {
41                 a.increase();
42             }
43             System.out.println(a.getA());
44         }).start();
45     }
46 }

 

运行结果以下，volatile没法保证a++操做的原子性。

volatile正确的使用方法可参考：https://blog.csdn.net/vking_wang/article/details/9982709