第十八篇：第五篇中volatile意外问题的正确分析解答（含代码）

最新推荐文章于 2021-07-21 16:31:02 发布

咖啡Q伴侣

最新推荐文章于 2021-07-21 16:31:02 发布

阅读量252

点赞数

CC 4.0 BY-SA版权

分类专栏： Java并发编程文章标签：多线程

本文链接：https://blog.youkuaiyun.com/u012426327/article/details/77470890

Java并发编程专栏收录该内容

30 篇文章

订阅专栏

本文探讨了Java中volatile变量的可见性问题，特别是在多线程环境下，即使未标记为volatile的变量也可能展现出最新的值的现象。通过代码示例和深入分析，揭示了JVM内存模型对volatile变量的处理机制。

一文中遗留了一个问题，就是volatile只修饰了missedIt变量，而没修饰value变量，但是在线程读取value的值的时候，也读到的是最新的数据。但是在网上查了很多资料都无果，看来很多人对volatile的规则并不是太清晰，或者说只停留在很表面的层次，一知半解。

这两天看《深入Java虚拟机——JVM高级特性与最佳实践》第12章：Java内存模型与线程，并在网上查阅了Java内存模型相关资料，学到了不少东西，尤其在看这篇文章的volatile部分的讲解之后，算是确定了问题出现的原因。

首先明确一点：假如有两个线程分别读写volatile变量时，线程A写入了某volatile变量，线程B在读取该volatile变量时，便能看到线程A对该volatile变量的写入操作，关键在这里，它不仅会看到对该volatile变量的写入操作，A线程在写volatile变量之前所有可见的共享变量，在B线程读同一个volatile变量后，都将立即变得对B线程可见。

回过头来看文章中出现的问题，由于程序中volatile变量missedIt的写入操作在value变量写入操作之后，而且根据volatile规则，又不能重排序，因此，在线程B读取由线程A改变后的missedIt之后，它之前的value变量在线程A的改变也对线程B变得可见了。

我们颠倒一下value=50和missedIt=true这两行代码试下，即missedIt=true在前，value=50在后，这样便会得到我们想要的结果：value值的改变不会被看到。

这应该是JDK1.2之后对volatile规则做了一些修订的结果。

修改后的代码如下：

[java]view plaincopy 
   
 public class Volatile extends Object implements Runnable {  
     //value变量没有被标记为volatile  
     private int value;    
     //missedIt变量被标记为volatile  
     private volatile boolean missedIt;  
     //creationTime不需要声明为volatile，因为代码执行中它没有发生变化  
     private long creationTime;   
   
     public Volatile() {  
         value = 10;  
         missedIt = false;  
         //获取当前时间，亦即调用Volatile构造函数时的时间  
         creationTime = System.currentTimeMillis();  
     }  
   
     public void run() {  
         print("entering run()");  
   
         //循环检查value的值是否不同  
         while ( value < 20 ) {  
             //如果missedIt的值被修改为true，则通过break退出循环  
             if  ( missedIt ) {  
                 //进入同步代码块前，将value的值赋给currValue  
                 int currValue = value;  
                 //在一个任意对象上执行同步语句，目的是为了让该线程在进入和离开同步代码块时，  
                 //将该线程中的所有变量的私有拷贝与共享内存中的原始值进行比较，  
                 //从而发现没有用volatile标记的变量所发生的变化  
                 Object lock = new Object();  
                 synchronized ( lock ) {  
                     //不做任何事  
                 }  
                 //离开同步代码块后，将此时value的值赋给valueAfterSync  
                 int valueAfterSync = value;  
                 print("in run() - see value=" + currValue +", but rumor has it that it changed!");  
                 print("in run() - valueAfterSync=" + valueAfterSync);  
                 break;   
             }  
         }  
         print("leaving run()");  
     }  
   
     public void workMethod() throws InterruptedException {  
         print("entering workMethod()");  
         print("in workMethod() - about to sleep for 2 seconds");  
         Thread.sleep(2000);  
         //仅在此改变value的值  
         missedIt = true;  
 //      value = 50;  
         print("in workMethod() - just set value=" + value);  
         print("in workMethod() - about to sleep for 5 seconds");  
         Thread.sleep(5000);  
         //仅在此改变missedIt的值  
 //      missedIt = true;  
         value = 50;  
         print("in workMethod() - just set missedIt=" + missedIt);  
         print("in workMethod() - about to sleep for 3 seconds");  
         Thread.sleep(3000);  
         print("leaving workMethod()");  
     }  
   
 /* 
 *该方法的功能是在要打印的msg信息前打印出程序执行到此所化去的时间，以及打印msg的代码所在的线程 
 */  
     private void print(String msg) {  
         //使用java.text包的功能，可以简化这个方法，但是这里没有利用这一点  
         long interval = System.currentTimeMillis() - creationTime;  
         String tmpStr = "    " + ( interval / 1000.0 ) + "000";       
         int pos = tmpStr.indexOf(".");  
         String secStr = tmpStr.substring(pos - 2, pos + 4);  
         String nameStr = "        " + Thread.currentThread().getName();  
         nameStr = nameStr.substring(nameStr.length() - 8, nameStr.length());      
         System.out.println(secStr + " " + nameStr + ": " + msg);  
     }  
   
     public static void main(String[] args) {  
         try {  
             //通过该构造函数可以获取实时时钟的当前时间  
             Volatile vol = new Volatile();  
   
             //稍停100ms，以让实时时钟稍稍超前获取时间，使print（）中创建的消息打印的时间值大于0  
             Thread.sleep(100);    
   
             Thread t = new Thread(vol);  
             t.start();  
   
             //休眠100ms，让刚刚启动的线程有时间运行  
             Thread.sleep(100);    
             //workMethod方法在main线程中运行  
             vol.workMethod();  
         } catch ( InterruptedException x ) {  
             System.err.println("one of the sleeps was interrupted");  
         }  
     }  
 }  