如何在Java中正确使用wait,notify和notifyAll

wait, notify 和 notifyAll，这些在多线程中被经常用到的保留关键字，在实际开发的时候很多时候却并没有被大家重视。本文对这些关键字的使用进行了描述。

公司主营业务：做网站、成都做网站、移动网站开发等业务。帮助企业客户真正实现互联网宣传，提高企业的竞争能力。成都创新互联是一支青春激扬、勤奋敬业、活力青春激扬、勤奋敬业、活力澎湃、和谐高效的团队。公司秉承以“开放、自由、严谨、自律”为核心的企业文化，感谢他们对我们的高要求，感谢他们从不同领域给我们带来的挑战，让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。成都创新互联推出让胡路免费做网站回馈大家。

在 Java 中可以用 wait、notify 和 notifyAll 来实现线程间的通信。举个例子，如果你的Java程序中有两个线程——即生产者和消费者，那么生产者可以通知消费者，让消费者开始消耗数据，因为队列缓 冲区中有内容待消费（不为空）。相应的，消费者可以通知生产者可以开始生成更多的数据，因为当它消耗掉某些数据后缓冲区不再为满。

我们可以利用wait()来让一个线程在某些条件下暂停运行。例如，在生产者消费者模型中，生产者线程在缓冲区为满的时候，消费者在缓冲区为空的时 候，都应该暂停运行。如果某些线程在等待某些条件触发，那当那些条件为真时，你可以用 notify 和 notifyAll 来通知那些等待中的线程重新开始运行。不同之处在于，notify 仅仅通知一个线程，并且我们不知道哪个线程会收到通知，然而 notifyAll 会通知所有等待中的线程。换言之，如果只有一个线程在等待一个信号灯，notify和notifyAll都会通知到这个线程。但如果多个线程在等待这个信 号灯，那么notify只会通知到其中一个，而其它线程并不会收到任何通知，而notifyAll会唤醒所有等待中的线程。

在这篇文章中你将会学到如何使用 wait、notify 和 notifyAll 来实现线程间的通信，从而解决生产者消费者问题。如果你想要更深入地学习Java中的多线程同步问题，我强烈推荐阅读Brian Goetz所著的《Java Concurrency in Practice | Java 并发实践》，不读这本书你的 Java 多线程征程就不完整哦！这是我最向Java开发者推荐的书之一。

如何使用Wait

尽管关于wait和notify的概念很基础，它们也都是Object类的函数，但用它们来写代码却并不简单。如果你在面试中让应聘者来手写代码， 用wait和notify解决生产者消费者问题，我几乎可以肯定他们中的大多数都会无所适从或者犯下一些错误，例如在错误的地方使用 synchronized 关键词，没有对正确的对象使用wait，或者没有遵循规范的代码方法。说实话，这个问题对于不常使用它们的程序员来说确实令人感觉比较头疼。

***个问题就是，我们怎么在代码里使用wait()呢？因为wait()并不是Thread类下的函数，我们并不能使用 Thread.call()。事实上很多Java程序员都喜欢这么写，因为它们习惯了使用Thread.sleep()，所以他们会试图使用wait() 来达成相同的目的，但很快他们就会发现这并不能顺利解决问题。正确的方法是对在多线程间共享的那个Object来使用wait。在生产者消费者问题中，这 个共享的Object就是那个缓冲区队列。

第二个问题是，既然我们应该在synchronized的函数或是对象里调用wait，那哪个对象应该被synchronized呢？答案是，那个 你希望上锁的对象就应该被synchronized，即那个在多个线程间被共享的对象。在生产者消费者问题中，应该被synchronized的就是那个 缓冲区队列。（我觉得这里是英文原文有问题……本来那个句末就不应该是问号不然不太通……）

永远在循环（loop）里调用 wait 和 notify，不是在 If 语句

现在你知道wait应该永远在被synchronized的背景下和那个被多线程共享的对象上调用，下一个一定要记住的问题就是，你应该永远在 while循环，而不是if语句中调用wait。因为线程是在某些条件下等待的——在我们的例子里，即“如果缓冲区队列是满的话，那么生产者线程应该等 待”，你可能直觉就会写一个if语句。但if语句存在一些微妙的小问题，导致即使条件没被满足，你的线程你也有可能被错误地唤醒。所以如果你不在线程被唤 醒后再次使用while循环检查唤醒条件是否被满足，你的程序就有可能会出错——例如在缓冲区为满的时候生产者继续生成数据，或者缓冲区为空的时候消费者 开始小号数据。所以记住，永远在while循环而不是if语句中使用wait！我会推荐阅读《Effective Java》，这是关于如何正确使用wait和notify的***的参考资料。

基于以上认知，下面这个是使用wait和notify函数的规范代码模板：

 
 
    
  
  
  1. // The standard idiom for calling the wait method in Java 
    2. 
  
  
  2. synchronized (sharedObject) { 
    3. 
  
  
  3.     while (condition) { 
    4. 
  
  
  4. sharedObject.wait(); 
    5. 
  
  
  5.         // (Releases lock, and reacquires on wakeup) 
    6. 
  
  
  6.     } 
    7. 
  
  
  7.     // do action based upon condition e.g. take or put into queue 
    8. 
  
  
  8. } 
    9.

就像我之前说的一样，在while循环里使用wait的目的，是在线程被唤醒的前后都持续检查条件是否被满足。如果条件并未改变，wait被调用之前notify的唤醒通知就来了，那么这个线程并不能保证被唤醒，有可能会导致死锁问题。

Java wait(), notify(), notifyAll() 范例

下面我们提供一个使用wait和notify的范例程序。在这个程序里，我们使用了上文所述的一些代码规范。我们有两个线程，分别名为 PRODUCER（生产者）和CONSUMER（消费者），他们分别继承了了Producer和Consumer类，而Producer和 Consumer都继承了Thread类。Producer和Consumer想要实现的代码逻辑都在run()函数内。Main线程开始了生产者和消费 者线程，并声明了一个LinkedList作为缓冲区队列（在Java中，LinkedList实现了队列的接口）。生产者在***循环中持续往 LinkedList里插入随机整数直到LinkedList满。我们在while(queue.size == maxSize)循环语句中检查这个条件。请注意到我们在做这个检查条件之前已经在队列对象上使用了synchronized关键词，因而其它线程不能在 我们检查条件时改变这个队列。如果队列满了，那么PRODUCER线程会在CONSUMER线程消耗掉队列里的任意一个整数，并用notify来通知 PRODUCER线程之前持续等待。在我们的例子中，wait和notify都是使用在同一个共享对象上的。

 
 
    
  
  
  1. import java.util.LinkedList; 
    2. 
  
  
  2. import java.util.Queue; 
    3. 
  
  
  3. import java.util.Random; 
    4. 
  
  
  4. /** 
    5. 
  
  
  5. * Simple Java program to demonstrate How to use wait, notify and notifyAll() 
    6. 
  
  
  6. * method in Java by solving producer consumer problem. 
    7. 
  
  
  7. * 
    8. 
  
  
  8. * @author Javin Paul 
    9. 
  
  
  9. */ 
    10. 
  
  
  10. public class ProducerConsumerInJava { 
    11. 
  
  
  11. public static void main(String args[]) { 
    12. 
  
  
  12.   System.out.println("How to use wait and notify method in Java"); 
    13. 
  
  
  13.   System.out.println("Solving Producer Consumper Problem"); 
    14. 
  
  
  14.   Queue<Integer> buffer = new LinkedList<>(); 
    15. 
  
  
  15.   int maxSize = 10; 
    16. 
  
  
  16.   Thread producer = new Producer(buffer, maxSize, "PRODUCER"); 
    17. 
  
  
  17.   Thread consumer = new Consumer(buffer, maxSize, "CONSUMER"); 
    18. 
  
  
  18.   producer.start(); consumer.start(); } 
    19. 
  
  
  19. } 
    20. 
  
  
  20. /** 
    21. 
  
  
  21. * Producer Thread will keep producing values for Consumer 
    22. 
  
  
  22. * to consumer. It will use wait() method when Queue is full 
    23. 
  
  
  23. * and use notify() method to send notification to Consumer 
    24. 
  
  
  24. * Thread. 
    25. 
  
  
  25. * 
    26. 
  
  
  26. * @author WINDOWS 8 
    27. 
  
  
  27. * 
    28. 
  
  
  28. */ 
    29. 
  
  
  29. class Producer extends Thread 
    30. 
  
  
  30. { private Queue<Integer> queue; 
    31. 
  
  
  31.   private int maxSize; 
    32. 
  
  
  32.   public Producer(Queue<Integer> queue, int maxSize, String name){ 
    33. 
  
  
  33.    super(name); this.queue = queue; this.maxSize = maxSize; 
    34. 
  
  
  34.   } 
    35. 
  
  
  35.   @Override public void run() 
    36. 
  
  
  36.   { 
    37. 
  
  
  37.    while (true) 
    38. 
  
  
  38.     { 
    39. 
  
  
  39.      synchronized (queue) { 
    40. 
  
  
  40.       while (queue.size() == maxSize) { 
    41. 
  
  
  41.        try { 
    42. 
  
  
  42.         System.out .println("Queue is full, " + "Producer thread waiting for " + "consumer to take something from queue"); 
    43. 
  
  
  43.         queue.wait(); 
    44. 
  
  
  44.        } catch (Exception ex) { 
    45. 
  
  
  45.         ex.printStackTrace(); } 
    46. 
  
  
  46.        } 
    47. 
  
  
  47.        Random random = new Random(); 
    48. 
  
  
  48.        int i = random.nextInt(); 
    49. 
  
  
  49.        System.out.println("Producing value : " + i); queue.add(i); queue.notifyAll(); 
    50. 
  
  
  50.       } 
    51. 
  
  
  51.      } 
    52. 
  
  
  52.     } 
    53. 
  
  
  53.    } 
    54. 
  
  
  54. /** 
    55. 
  
  
  55. * Consumer Thread will consumer values form shared queue. 
    56. 
  
  
  56. * It will also use wait() method to wait if queue is 
    57. 
  
  
  57. * empty. It will also use notify method to send 
    58. 
  
  
  58. * notification to producer thread after consuming values 
    59. 
  
  
  59. * from queue. 
    60. 
  
  
  60. * 
    61. 
  
  
  61. * @author WINDOWS 8 
    62. 
  
  
  62. * 
    63. 
  
  
  63. */ 
    64. 
  
  
  64. class Consumer extends Thread { 
    65. 
  
  
  65.   private Queue<Integer> queue; 
    66. 
  
  
  66.   private int maxSize; 
    67. 
  
  
  67.   public Consumer(Queue<Integer> queue, int maxSize, String name){ 
    68. 
  
  
  68.    super(name); 
    69. 
  
  
  69.    this.queue = queue; 
    70. 
  
  
  70.    this.maxSize = maxSize; 
    71. 
  
  
  71.   } 
    72. 
  
  
  72.   @Override public void run() { 
    73. 
  
  
  73.    while (true) { 
    74. 
  
  
  74.     synchronized (queue) { 
    75. 
  
  
  75.      while (queue.isEmpty()) { 
    76. 
  
  
  76.       System.out.println("Queue is empty," + "Consumer thread is waiting" + " for producer thread to put something in queue"); 
    77. 
  
  
  77.       try { 
    78. 
  
  
  78.        queue.wait(); 
    79. 
  
  
  79.       } catch (Exception ex) { 
    80. 
  
  
  80.        ex.printStackTrace(); 
    81. 
  
  
  81.       } 
    82. 
  
  
  82.      } 
    83. 
  
  
  83.      System.out.println("Consuming value : " + queue.remove()); queue.notifyAll(); 
    84. 
  
  
  84.     } 
    85. 
  
  
  85.    } 
    86. 
  
  
  86.   } 
    87. 
  
  
  87. } 
    88.

为了更好地理解这个程序，我建议你在debug模式里跑这个程序。一旦你在debug模式下启动程序，它会停止在PRODUCER或者 CONSUMER线程上，取决于哪个线程占据了CPU。因为两个线程都有wait()的条件，它们一定会停止，然后你就可以跑这个程序然后看发生什么了 （很有可能它就会输出我们以上展示的内容）。你也可以使用Eclipse里的Step into和Step over按钮来更好地理解多线程间发生的事情。

本文重点：

1. 你可以使用wait和notify函数来实现线程间通信。你可以用它们来实现多线程（>3）之间的通信。

2. 永远在synchronized的函数或对象里使用wait、notify和notifyAll，不然Java虚拟机会生成 IllegalMonitorStateException。

3. 永远在while循环里而不是if语句下使用wait。这样，循环会在线程睡眠前后都检查wait的条件，并在条件实际上并未改变的情况下处理唤醒通知。

4. 永远在多线程间共享的对象（在生产者消费者模型里即缓冲区队列）上使用wait。

5. 基于前文提及的理由，更倾向用 notifyAll()，而不是 notify()。

这是关于Java里如何使用wait, notify和notifyAll的所有重点啦。你应该只在你知道自己要做什么的情况下使用这些函数，不然Java里还有很多其它的用来解决同步问题的方 案。例如，如果你想使用生产者消费者模型的话，你也可以使用BlockingQueue，它会帮你处理所有的线程安全问题和流程控制。如果你想要某一个线 程等待另一个线程做出反馈再继续运行，你也可以使用CycliBarrier或者CountDownLatch。如果你只是想保护某一个资源的话，你也可 以使用Semaphore。

网页题目：如何在Java中正确使用wait,notify和notifyAll
链接分享：http://www.shufengxianlan.com/qtweb/news1/244201.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

企业网站制作知识

行业网站建设

主动防护网　　 　宜宾网站设计　　 　重庆外贸网站建设　　 　犀浦封阳台　　 　橡塑保温管　　 　达州网站建设　　 　明安消防器材　　 　成都免费自助建站　　 　成都SEO优化　　 　崇州网站建设　　 　西部信息机房　　 　成都网站推广　　 　绵阳服务器托管　　 　成都网站建设　　 　成都网络推广　　 　成都电信服务器托管　　 　营销网站建设　　 　资阳服务器托管　　 　中国电信成都枢纽中心　　 　渠县网站建设