【Java并发编程】:第五篇中volatile意外问题的正确分析解答(含代码)

《Java并发编程学习笔记: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 plain copy
  1. public class Volatile extends Object implements Runnable {  
  2.     //value变量没有被标记为volatile  
  3.     private int value;    
  4.     //missedIt变量被标记为volatile  
  5.     private volatile boolean missedIt;  
  6.     //creationTime不需要声明为volatile,因为代码执行中它没有发生变化  
  7.     private long creationTime;   
  8.   
  9.     public Volatile() {  
  10.         value = 10;  
  11.         missedIt = false;  
  12.         //获取当前时间,亦即调用Volatile构造函数时的时间  
  13.         creationTime = System.currentTimeMillis();  
  14.     }  
  15.   
  16.     public void run() {  
  17.         print("entering run()");  
  18.   
  19.         //循环检查value的值是否不同  
  20.         while ( value < 20 ) {  
  21.             //如果missedIt的值被修改为true,则通过break退出循环  
  22.             if  ( missedIt ) {  
  23.                 //进入同步代码块前,将value的值赋给currValue  
  24.                 int currValue = value;  
  25.                 //在一个任意对象上执行同步语句,目的是为了让该线程在进入和离开同步代码块时,  
  26.                 //将该线程中的所有变量的私有拷贝与共享内存中的原始值进行比较,  
  27.                 //从而发现没有用volatile标记的变量所发生的变化  
  28.                 Object lock = new Object();  
  29.                 synchronized ( lock ) {  
  30.                     //不做任何事  
  31.                 }  
  32.                 //离开同步代码块后,将此时value的值赋给valueAfterSync  
  33.                 int valueAfterSync = value;  
  34.                 print("in run() - see value=" + currValue +", but rumor has it that it changed!");  
  35.                 print("in run() - valueAfterSync=" + valueAfterSync);  
  36.                 break;   
  37.             }  
  38.         }  
  39.         print("leaving run()");  
  40.     }  
  41.   
  42.     public void workMethod() throws InterruptedException {  
  43.         print("entering workMethod()");  
  44.         print("in workMethod() - about to sleep for 2 seconds");  
  45.         Thread.sleep(2000);  
  46.         //仅在此改变value的值  
  47.         missedIt = true;  
  48. //      value = 50;  
  49.         print("in workMethod() - just set value=" + value);  
  50.         print("in workMethod() - about to sleep for 5 seconds");  
  51.         Thread.sleep(5000);  
  52.         //仅在此改变missedIt的值  
  53. //      missedIt = true;  
  54.         value = 50;  
  55.         print("in workMethod() - just set missedIt=" + missedIt);  
  56.         print("in workMethod() - about to sleep for 3 seconds");  
  57.         Thread.sleep(3000);  
  58.         print("leaving workMethod()");  
  59.     }  
  60.   
  61. /* 
  62. *该方法的功能是在要打印的msg信息前打印出程序执行到此所化去的时间,以及打印msg的代码所在的线程 
  63. */  
  64.     private void print(String msg) {  
  65.         //使用java.text包的功能,可以简化这个方法,但是这里没有利用这一点  
  66.         long interval = System.currentTimeMillis() - creationTime;  
  67.         String tmpStr = "    " + ( interval / 1000.0 ) + "000";       
  68.         int pos = tmpStr.indexOf(".");  
  69.         String secStr = tmpStr.substring(pos - 2, pos + 4);  
  70.         String nameStr = "        " + Thread.currentThread().getName();  
  71.         nameStr = nameStr.substring(nameStr.length() - 8, nameStr.length());      
  72.         System.out.println(secStr + " " + nameStr + ": " + msg);  
  73.     }  
  74.   
  75.     public static void main(String[] args) {  
  76.         try {  
  77.             //通过该构造函数可以获取实时时钟的当前时间  
  78.             Volatile vol = new Volatile();  
  79.   
  80.             //稍停100ms,以让实时时钟稍稍超前获取时间,使print()中创建的消息打印的时间值大于0  
  81.             Thread.sleep(100);    
  82.   
  83.             Thread t = new Thread(vol);  
  84.             t.start();  
  85.   
  86.             //休眠100ms,让刚刚启动的线程有时间运行  
  87.             Thread.sleep(100);    
  88.             //workMethod方法在main线程中运行  
  89.             vol.workMethod();  
  90.         } catch ( InterruptedException x ) {  
  91.             System.err.println("one of the sleeps was interrupted");  
  92.         }  
  93.     }  
  94. }  
    执行结果如下:
【Java并发编程】:第五篇中volatile意外问题的正确分析解答(含代码)_第1张图片


   很明显,这其实并不符合使用volatile的第二个条件:该变量要没有包含在具有其他变量的不变式中。因此,在这里使用volatile是不安全的。




附上一篇讲述volatile关键字正确使用的很好的文章:http://www.ibm.com/developerworks/cn/java/j-jtp06197.html

你可能感兴趣的:(java,多线程,并发)