转:【Java并发编程】之十二:线程间通信中notifyAll造成的早期通知问题(含代码)

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

如果线程在等待时接到通知,但线程等待的条件还不满足,此时,线程接到的就是早期通知,如果条件满足的时间很短,但很快又改变了,而变得不再满足,这时也将发生早期通知。这种现象听起来很奇怪,下面通过一个示例程序来说明问题。

很简单,两个线程等待删除List中的元素,同时另外一个线程正要向其中添加项目。代码如下:

[java] view plain copy

  1. import java.util.*;
  2. public class EarlyNotify extends Object {
  3. private List list;
  4. public EarlyNotify() {
  5. list = Collections.synchronizedList(new LinkedList());
  6. }
  7. public String removeItem() throws InterruptedException {
  8. print("in removeItem() - entering");
  9. synchronized ( list ) {
  10. if ( list.isEmpty() ) {  //这里用if语句会发生危险
  11. print("in removeItem() - about to wait()");
  12. list.wait();
  13. print("in removeItem() - done with wait()");
  14. }
  15. //删除元素
  16. String item = (String) list.remove(0);
  17. print("in removeItem() - leaving");
  18. return item;
  19. }
  20. }
  21. public void addItem(String item) {
  22. print("in addItem() - entering");
  23. synchronized ( list ) {
  24. //添加元素
  25. list.add(item);
  26. print("in addItem() - just added: ‘" + item + "‘");
  27. //添加后,通知所有线程
  28. list.notifyAll();
  29. print("in addItem() - just notified");
  30. }
  31. print("in addItem() - leaving");
  32. }
  33. private static void print(String msg) {
  34. String name = Thread.currentThread().getName();
  35. System.out.println(name + ": " + msg);
  36. }
  37. public static void main(String[] args) {
  38. final EarlyNotify en = new EarlyNotify();
  39. Runnable runA = new Runnable() {
  40. public void run() {
  41. try {
  42. String item = en.removeItem();
  43. print("in run() - returned: ‘" +
  44. item + "‘");
  45. } catch ( InterruptedException ix ) {
  46. print("interrupted!");
  47. } catch ( Exception x ) {
  48. print("threw an Exception!!!\n" + x);
  49. }
  50. }
  51. };
  52. Runnable runB = new Runnable() {
  53. public void run() {
  54. en.addItem("Hello!");
  55. }
  56. };
  57. try {
  58. //启动第一个删除元素的线程
  59. Thread threadA1 = new Thread(runA, "threadA1");
  60. threadA1.start();
  61. Thread.sleep(500);
  62. //启动第二个删除元素的线程
  63. Thread threadA2 = new Thread(runA, "threadA2");
  64. threadA2.start();
  65. Thread.sleep(500);
  66. //启动增加元素的线程
  67. Thread threadB = new Thread(runB, "threadB");
  68. threadB.start();
  69. Thread.sleep(10000); // wait 10 seconds
  70. threadA1.interrupt();
  71. threadA2.interrupt();
  72. } catch ( InterruptedException x ) {}
  73. }
  74. }

执行结果如下:

分析:首先启动threadA1,threadA1在removeItem()中调用wait(),从而释放list上的对象锁。再过500ms,启动threadA2,threadA2调用removeItem(),获取list上的对象锁,也发现列表为空,从而在wait()方法处阻塞,释放list上的对象锁。再过500ms后,启动threadB,并调用addItem,获得list上的对象锁,并在list中添加一个元素,同时用notifyAll通知所有线程。

threadA1和threadA2都从wait()返回,等待获取list对象上的对象锁,并试图从列表中删除添加的元素,这就会产生麻烦,只有其中一个操作能成功。假设threadA1获取了list上的对象锁,并删除元素成功,在退出synchronized代码块时,它便会释放list上的对象锁,此时threadA2便会获取list上的对象锁,会继续删除list中的元素,但是list已经为空了,这便会抛出IndexOutOfBoundsException。

要避免以上问题只需将wait外围的if语句改为while循环即可,这样当list为空时,线程便会继续等待,而不会继续去执行删除list中元素的代码。

修改后的执行结果如下:

总结:在使用线程的等待/通知机制时,一般都要在while循环中调用wait()方法,满足条件时,才让while循环退出,这样一般也要配合使用一个boolean变量(或其他能判断真假的条件,如本文中的list.isEmpty()),满足while循环的条件时,进入while循环,执行wait()方法,不满足while循环的条件时,跳出循环,执行后面的代码。

时间: 2024-10-13 12:42:02

转:【Java并发编程】之十二:线程间通信中notifyAll造成的早期通知问题(含代码)的相关文章

【Java并发编程】之十二:线程间通信中notifyAll造成的早期通知问题(含代码)

如果线程在等待时接到通知,但线程等待的条件还不满足,此时,线程接到的就是早期通知,如果条件满足的时间很短,但很快又改变了,而变得不再满足,这时也将发生早期通知.这种现象听起来很奇怪,下面通过一个示例程序来说明问题. 很简单,两个线程等待删除List中的元素,同时另外一个线程正要向其中添加项目.代码如下: [java] view plaincopy import java.util.*; public class EarlyNotify extends Object { private List 

Java并发编程的艺术(六)——线程间的通信

多条线程之间有时需要数据交互,下面介绍五种线程间数据交互的方式,他们的使用场景各有不同. 1. volatile.synchronized关键字 PS:关于volatile的详细介绍请移步至:Java并发编程的艺术(三)--volatile 1.1 如何实现通信? 这两种方式都采用了同步机制实现多条线程间的数据通信.与其说是"通信",倒不如说是"共享变量"来的恰当.当一个共享变量被volatile修饰 或 被同步块包裹后,他们的读写操作都会直接操作共享内存,从而各个

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

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

java并发编程(十一)线程间的通信notify通知的遗漏

notify通知的遗漏很容易理解,即threadA还没开始wait的时候,threadB已经notify了,这样,threadB通知是没有任何响应的,当threadB退出synchronized代码块后,threadA再开始wait,便会一直阻塞等待,直到被别的线程打断. 实例见 :https://git.oschina.net/wenjieyatou/threadTest 在threadB进行通知之前,先将okToProceed置为true,这样如果threadA将通知遗漏,那么就不会进入wh

Java并发编程(九)线程间协作(下)

上篇我们讲了使用wait()和notify()使线程间实现合作,这种方式很直接也很灵活,但是使用之前需要获取对象的锁,notify()调用的次数如果小于等待线程的数量就会导致有的线程会一直等待下去.这篇我们讲多线程间接协作的方式,阻塞队列和管道通讯,间接协作的优点是使用起来更简单并且不易出错. 阻塞队列 阻塞队列提供了一种功能,即你可以在任何时刻向队列内扔一个对象,如果队列满了则当前线程阻塞:在任何时刻都可以从队列中取出一个对象,如果队列为空则当前线程阻塞.阻塞队列是线程安全的,使用它时无需加锁

Java并发编程(十二)线程安全性的委托

在组合对象中如果每个组件都已经是线程安全的,是否需要再加一个额外的"线程安全层",需要视情况而定. final可以修饰未复制的属性,只要在静态代码块或者构造函数中赋值了即可. 独立的状态变量 我们还可以将线程的安全性委托给多个状态变量,只要这些变量是彼此独立的,即组合而成的类并不会在其包含的多个状态变量上增加任何不变性条件. 如果是状态变量之间存在着某些不变性条件时就没这么简单了.比如一个类中有两个属性,要满足的条件是一个属性的值要小于另一个属性的值.这是比较典型的先检查后执行的操作,

【转】Java并发编程:如何创建线程?

一.Java中关于应用程序和进程相关的概念 在Java中,一个应用程序对应着一个JVM实例(也有地方称为JVM进程),一般来说名字默认是java.exe或者javaw.exe(windows下可以通过任务管理器查看).Java采用的是单线程编程模型,即在我们自己的程序中如果没有主动创建线程的话,只会创建一个线程,通常称为主线程.但是要注意,虽然只有一个线程来执行任务,不代表JVM中只有一个线程,JVM实例在创建的时候,同时会创建很多其它的线程(比如垃圾收集器线程). 由于Java采用的是单线程编

Java并发编程:进程和线程

.title { text-align: center } .todo { font-family: monospace; color: red } .done { color: green } .tag { background-color: #eee; font-family: monospace; padding: 2px; font-size: 80%; font-weight: normal } .timestamp { color: #bebebe } .timestamp-kwd

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

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