转: 【Java并发编程】之五:volatile变量修饰符—意料之外的问题(含代码)

转载请注明出处:

    volatile用处说明

    在JDK1.2之前,Java的内存模型实现总是从主存(即共享内存)读取变量,是不需要进行特别的注意的。而随着JVM的成熟和优化,现在在多线程环境下volatile关键字的使用变得非常重要。

在当前的Java内存模型下,线程可以把变量保存在本地内存(比如机器的寄存器)中,而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值,而另外一个线程还继续使用它在寄存器中的变量值的拷贝,造成数据的不一致。

要解决这个问题,就需要把变量声明为volatile(也可以使用同步,参见http://blog.csdn.net/ns_code/article/details/17288243),这就指示JVM,这个变量是不稳定的,每次使用它都到主存中进行读取。一般说来,多任务环境下,各任务间共享的变量都应该加volatile修饰符。

Volatile修饰的成员变量在每次被线程访问时,都强迫从共享内存中重读该成员变量的值。而且,当成员变量发生变化时,强迫线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。

Java语言规范中指出:为了获得最佳速度,允许线程保存共享成员变量的私有拷贝,而且只当线程进入或者离开同步代码块时才将私有拷贝与共享内存中的原始值进行比较。

这样当多个线程同时与某个对象交互时,就必须注意到要让线程及时的得到共享成员变量的变化。而volatile关键字就是提示JVM:对于这个成员变量,不能保存它的私有拷贝,而应直接与共享成员变量交互。

volatile是一种稍弱的同步机制,在访问volatile变量时不会执行加锁操作,也就不会执行线程阻塞,因此volatilei变量是一种比synchronized关键字更轻量级的同步机制。

使用建议:在两个或者更多的线程需要访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中,或者为常量时,没必要使用volatile。

由于使用volatile屏蔽掉了JVM中必要的代码优化,所以在效率上比较低,因此一定在必要时才使用此关键字

示例程序

下面给出一段代码,通过其运行结果来说明使用关键字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. value = 50;
  44. print("in workMethod() - just set value=" + value);
  45. print("in workMethod() - about to sleep for 5 seconds");
  46. Thread.sleep(5000);
  47. //仅在此改变missedIt的值
  48. missedIt = true;
  49. print("in workMethod() - just set missedIt=" + missedIt);
  50. print("in workMethod() - about to sleep for 3 seconds");
  51. Thread.sleep(3000);
  52. print("leaving workMethod()");
  53. }
  54. /*
  55. *该方法的功能是在要打印的msg信息前打印出程序执行到此所化去的时间,以及打印msg的代码所在的线程
  56. */
  57. private void print(String msg) {
  58. //使用java.text包的功能,可以简化这个方法,但是这里没有利用这一点
  59. long interval = System.currentTimeMillis() - creationTime;
  60. String tmpStr = "    " + ( interval / 1000.0 ) + "000";
  61. int pos = tmpStr.indexOf(".");
  62. String secStr = tmpStr.substring(pos - 2, pos + 4);
  63. String nameStr = "        " + Thread.currentThread().getName();
  64. nameStr = nameStr.substring(nameStr.length() - 8, nameStr.length());
  65. System.out.println(secStr + " " + nameStr + ": " + msg);
  66. }
  67. public static void main(String[] args) {
  68. try {
  69. //通过该构造函数可以获取实时时钟的当前时间
  70. Volatile vol = new Volatile();
  71. //稍停100ms,以让实时时钟稍稍超前获取时间,使print()中创建的消息打印的时间值大于0
  72. Thread.sleep(100);
  73. Thread t = new Thread(vol);
  74. t.start();
  75. //休眠100ms,让刚刚启动的线程有时间运行
  76. Thread.sleep(100);
  77. //workMethod方法在main线程中运行
  78. vol.workMethod();
  79. } catch ( InterruptedException x ) {
  80. System.err.println("one of the sleeps was interrupted");
  81. }
  82. }
  83. }

按照以上的理论来分析,由于value变量不是volatile的,因此它在main线程中的改变不会被Thread-0线程(在main线程中新开启的线程)马上看到,因此Thread-0线程中的while循环不会直接退出,它会继续判断missedIt的值,由于missedIt是volatile的,当main线程中改变了missedIt时,Thread-0线程会立即看到该变化,那么if语句中的代码便得到了执行的机会,由于此时Thread-0依然没有看到value值的变化,因此,currValue的值为10,继续向下执行,进入同步代码块,因为进入前后要将该线程内的变量值与共享内存中的原始值对比,进行校准,因此离开同步代码块后,Thread-0便会察觉到value的值变为了50,那么后面的valueAfterSync的值便为50,最后从break跳出循环,结束Thread-0线程。

意料之外的问题

但实际的执行结果如下:

从结果中可以看出,Thread-0线程并没有进入while循环,说明Thread-0线程在value的值发生变化后,missedIt的值发生变化前,便察觉到了value值的变化,从而退出了while循环。这与理论上的分析不符,我便尝试注释掉value值发生改变与missedIt值发生改变之间的线程休眠代码Thread.sleep(5000),以确保Thread-0线程在missedIt的值发生改变前,没有时间察觉到value值的变化。但执行的结果与上面大同小异(可能有一两行顺序不同,但依然不会打印出if语句中的输出信息)。

问题分析

在JDK1.7~JDK1.3之间的版本上输出结果与上面基本大同小异,只有在JDK1.2上才得到了预期的结果,即Thread-0线程中的while循环是从if语句中退出的,这说明Thread-0线程没有及时察觉到value值的变化。

这里需要注意:volatile是针对JIT带来的优化,因此JDK1.2以前的版本基本不用考虑,另外,在JDK1.3.1开始,开始运用HotSpot虚拟机,用来代替JIT。因此,是不是HotSpot的问题呢?这里需要再补充一点:

JIT或HotSpot编译器在server模式和client模式编译不同,server模式为了使线程运行更快,如果其中一个线程更改了变量boolean
flag
的值,那么另外一个线程会看不到,因为另外一个线程为了使得运行更快所以从寄存器或者本地cache中取值,而不是从内存中取值,那么使用volatile后,就告诉不论是什么线程,被volatile修饰的变量都要从内存中取值。《内存栅栏》

但看了这个帖子http://segmentfault.com/q/1010000000147713(也有人遇到同样的问题了)说,尝试了HotSpot的server和client两种模式,以及JDK1.3的classic,都没有效果,只有JDK1.2才能得到预期的结果。

哎!看来自己知识还是比较匮乏,看了下网友给出的答案,对于非volatile修饰的变量,尽管jvm的优化,会导致变量的可见性问题,但这种可见性的问题也只是在短时间内高并发的情况下发生,CPU执行时会很快刷新Cache,一般的情况下很难出现,而且出现这种问题是不可预测的,与jvm,
机器配置环境等都有关。

姑且先这么理解吧!一点点积累。。。

正确的分析在这里:http://blog.csdn.net/ns_code/article/details/17382679

这里附上分析结果时参考的帖子及文章

http://segmentfault.com/q/1010000000147713

http://www.iteye.com/problems/98213


http://www.oldcaptain.cc/articles/2013/08/21/1377092100971.html

时间: 2024-09-28 21:34:41

转: 【Java并发编程】之五:volatile变量修饰符—意料之外的问题(含代码)的相关文章

Java并发编程(5):volatile变量修饰符-意料之外的问题(含代码)

volatile用处说明在JDK1.2之前,Java的内存模型实现总是从主存(即共享内存)读取变量,是不需要进行特别的注意的.而随着JVM的成熟和优化,现在在多线程环境下volatile关键字的使用变得非常重要. 在当前的Java内存模型下,线程可以把变量保存在本地内存(比如机器的寄存器)中,而不是直接在主存中进行读写.这就可能造成一个线程在主存中修改了一个变量的值,而另外一个线程还继续使用它在寄存器中的变量值的拷贝,造成数据的不一致. 要解决这个问题,就需要把变量声明为volatile(也可以

转: 【Java并发编程】之十三:生产者—消费者模型(含代码)

转载请注明出处:http://blog.csdn.net/ns_code/article/details/17249321 生产者消费者问题是线程模型中的经典问题:生产者和消费者在同一时间段内共用同一存储空间,生产者向空间里生产数据,而消费者取走数据. 这里实现如下情况的生产--消费模型: 生产者不断交替地生产两组数据"姓名--1 --> 内容--1","姓名--2--> 内容--2",消费者不断交替地取得这两组数据,这里的"姓名--1&quo

Java并发编程】之十三:生产者—消费者模型(含代码)

生产者消费者问题是线程模型中的经典问题:生产者和消费者在同一时间段内共用同一存储空间,生产者向空间里生产数据,而消费者取走数据. 这里实现如下情况的生产--消费模型: 生产者不断交替地生产两组数据"姓名--1 --> 内容--1","姓名--2--> 内容--2",消费者不断交替地取得这两组数据,这里的"姓名--1"和"姓名--2"模拟为数据的名称,"内容--1 "和"内容--2 &q

6、Java并发编程:volatile关键字解析

Java并发编程:volatile关键字解析 volatile这个关键字可能很多朋友都听说过,或许也都用过.在Java 5之前,它是一个备受争议的关键字,因为在程序中使用它往往会导致出人意料的结果.在Java 5之后,volatile关键字才得以重获生机. volatile关键字虽然从字面上理解起来比较简单,但是要用好不是一件容易的事情.由于volatile关键字是与Java的内存模型有关的,因此在讲述volatile关键之前,我们先来了解一下与内存模型相关的概念和知识,然后分析了volatil

java并发编程(2)--volatile

转载:http://ifeve.com/volatile/ 作者:方 腾飞 花名清英,并发网(ifeve.com)创始人,畅销书<Java并发编程的艺术>作者,蚂蚁金服技术专家.目前工作于支付宝微贷事业部,关注互联网金融,并发编程和敏捷实践. Volatile是轻量级的synchronized,它在多处理器开发中保证了共享变量的“可见性”. 可见性的意思是当一个线程修改一个共享变量时,另外一个线程能读到这个修改的值. 共享变量:在多个线程之间能够被共享的变量被称为共享变量.共享变量包括所有的实

Java并发编程:volatile关键字解析 和双重检查(Double-Check)

转载:http://www.cnblogs.com/dolphin0520/p/3920373.html Java并发编程:volatile关键字解析 volatile这个关键字可能很多朋友都听说过,或许也都用过.在Java 5之前,它是一个备受争议的关键字,因为在程序中使用它往往会导致出人意料的结果.在Java 5之后,volatile关键字才得以重获生机. volatile关键字虽然从字面上理解起来比较简单,但是要用好不是一件容易的事情.由于volatile关键字是与Java的内存模型有关的

转 Java并发编程:volatile关键字解析

Java并发编程:volatile关键字解析 (点击链接原文) volatile这个关键字可能很多朋友都听说过,或许也都用过.在Java 5之前,它是一个备受争议的关键字,因为在程序中使用它往往会导致出人意料的结果.在Java 5之后,volatile关键字才得以重获生机. volatile关键字虽然从字面上理解起来比较简单,但是要用好不是一件容易的事情.由于volatile关键字是与Java的内存模型有关的,因此在讲述volatile关键之前,我们先来了解一下与内存模型相关的概念和知识,然后分

Java 并发编程:volatile的使用及其原理

Java并发编程系列[未完]: Java 并发编程:核心理论 Java并发编程:Synchronized及其实现原理 Java并发编程:Synchronized底层优化(轻量级锁.偏向锁) Java 并发编程:线程间的协作(wait/notify/sleep/yield/join) Java 并发编程:volatile的使用及其原理 一.volatile的作用 在<a href="http://www.cnblogs.com/paddix/p/5374810.html">&

java并发编程11.原子变量与非阻塞同步机制

在非阻塞算法中不存在死锁和其他活跃性问题. 在基于锁的算法中,如果一个线程在休眠或自旋的同时持有一个锁,那么其他线程都无法执行下去,而非阻塞算法不会受到单个线程失败的影响. 锁的劣势 许多JVM都对非竞争锁获取和释放操作进行了极大的优化,但如果有多个线程同时请求锁,那么JVM就需要借助操作系统地功能.如果出现了这种情况,那么一些线程将被挂起并且在稍后恢复运行.当线程恢复执行时,必须等待其他线程执行完它们的时间片以后,才能被调度执行.在挂起和恢复线程等过程中存在着很大的开销,并且通常存在着较大时间