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

转载请注明出处:http://blog.csdn.net/ns_code/article/details/17382679

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

执行结果如下:

很明显,这其实并不符合使用volatile的第二个条件:附上一篇讲述volatile关键字正确使用的很好的文章:http://www.ibm.com/developerworks/cn/java/j-jtp06197.html

时间: 2024-10-31 03:57:16

转: 【Java并发编程】之十八:第五篇中volatile意外问题的正确分析解答(含代码)的相关文章

转: 【Java并发编程】之三:线程挂起、恢复与终止的正确方法(含代码)

转载请注明出处:http://blog.csdn.net/ns_code/article/details/17095733 挂起和恢复线程     Thread 的API中包含两个被淘汰的方法,它们用于临时挂起和重启某个线程,这些方法已经被淘汰,因为它们是不安全的,不稳定的.如果在不合适的时候挂起线程(比如,锁定共享资源时),此时便可能会发生死锁条件--其他线程在等待该线程释放锁,但该线程却被挂起了,便会发生死锁.另外,在长时间计算期间挂起线程也可能导致问题. 下面的代码演示了通过休眠来延缓运行

java并发编程(十八)阻塞队列和阻塞栈

阻塞队列 阻塞队列是Java 5并发新特性中的内容,阻塞队列的接口是java.util.concurrent.BlockingQueue,它有多个实现类:ArrayBlockingQueue.DelayQueue.LinkedBlockingQueue.PriorityBlockingQueue.SynchronousQueue等,用法大同小异,具体可查看JDK文档,这里简单举例看下ArrayBlockingQueue,它实现了一个有界队列,当队列满时,便会阻塞等待,直到有元素出队,后续的元素才

Java并发编程(8):多线程环境中安全使用集合API(含代码)

Java并发编程(8):多线程环境中安全使用集合API(含代码)JAVA大数据中高级架构 2018-11-09 14:44:47在集合API中,最初设计的Vector和Hashtable是多线程安全的.例如:对于Vector来说,用来添加和删除元素的方法是同步的.如果只有一个线程与Vector的实例交互,那么,要求获取和释放对象锁便是一种浪费,另外在不必要的时候如果滥用同步化,也有可能会带来死锁.因此,对于更改集合内容的方法,没有一个是同步化的.集合本质上是非多线程安全的,当多个线程与集合交互时

Java 并发编程(三)为线程安全类中加入新的原子操作

Java 类库中包括很多实用的"基础模块"类.通常,我们应该优先选择重用这些现有的类而不是创建新的类.:重用能减少开发工作量.开发风险(由于现有类都已经通过測试)以及维护成本.有时候,某个线程安全类能支持我们须要的全部操作,但很多其它的时候,现有的类仅仅能支持大部分的操作,此时就须要在不破坏线程安全的情况下加入一个新的操作. 如果我们须要一个线程安全的链表,他须要提供一个原子的"若没有则加入(Put-If-Absent)"的操作.同步的 List 类已经实现了大部分

java并发编程(十六)happen-before规则

转载请注明出处:http://blog.csdn.net/ns_code/article/details/17348313 happen-before规则介绍 Java语言中有一个"先行发生"(happen-before)的规则,它是Java内存模型中定义的两项操作之间的偏序关系,如果操作A先行发生于操作B,其意思就是说,在发生操作B之前,操作A产生的影响都能被操作B观察到,"影响"包括修改了内存中共享变量的值.发送了消息.调用了方法等,它与时间上的先后发生基本没有

Java并发编程(十):并发容器之CopyOnWriteArrayList(转载)

原文链接: http://ifeve.com/java-copy-on-write/ Copy-On-Write简称COW,是一种用于程序设计中的优化策略.其基本思路是,从一开始大家都在共享同一个内容,当某个人想要修改这个内容的时候,才会真正把内容Copy出去形成一个新的内容然后再改,这是一种延时懒惰策略.从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器,它们是CopyOnWriteArrayList和CopyOnWriteArraySet.CopyOnW

Java并发编程(十二):线程池的使用(转载)

本文转载自:http://www.cnblogs.com/dolphin0520/p/3932921.html 在前面的文章中,我们使用线程的时候就去创建一个线程,这样实现起来非常简便,但是就会有一个问题: 如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间. 那么有没有一种办法使得线程可以复用,就是执行完一个任务,并不被销毁,而是可以继续执行其他的任务? 在Java中可以通过线程池来达到这样的效果.

Java并发编程(十)死锁

哲学家进餐问题 并发执行带来的最棘手的问题莫过于死锁了,死锁问题中最经典的案例就是哲学家进餐问题:5个哲学家坐在一个桌子上,桌子上有5根筷子,每个哲学家的左手边和右手边各有一根筷子.示意图如下: 哲学家进餐问题 并发执行带来的最棘手的问题莫过于死锁了,死锁问题中最经典的案例就是哲学家进餐问题:5个哲学家坐在一个桌子上,桌子上有5根筷子,每个哲学家的左手边和右手边各有一根筷子.示意图如下: 哲学家必须拿起左右两边的筷子才能进餐,如果他们同时拿起左手边的筷子,就会导致死锁.因为右手边的筷子被他右边的

Java并发编程(十四):Callable、Future和FutureTask(转载)

本文转载自:ttp://www.cnblogs.com/dolphin0520/p/3949310.html 在前面的文章中我们讲述了创建线程的2种方式,一种是直接继承Thread,另外一种就是实现Runnable接口. 这2种方式都有一个缺陷就是:在执行完任务之后无法获取执行结果. 如果需要获取执行结果,就必须通过共享变量或者使用线程通信的方式来达到效果,这样使用起来就比较麻烦. 而自从Java 1.5开始,就提供了Callable和Future,通过它们可以在任务执行完毕之后得到任务执行结果