经典模式:生产者-消费者模型:当队列满时,生产者需要等待队列有空间才能继续往里面放入商品,而在等待的期间内,生产者必须释放对临界资源(即队列)的占用权。因为生产者如果不释放对临界资源的占用权,那么消费者就无法消费队列中的商品,就不会让队列有空间,那么生产者就会一直无限等待下去。因此,一般情况下,当队列满时,会让生产者交出对临界资源的占用权,并进入挂起状态。然后等待消费者消费了商品,然后消费者通知生产者队列有空间了。同样地,当队列空时,消费者也必须等待,等待生产者通知它队列中有商品了。这种互相通信的过程就是线程间的协作。

转自 http://www.cnblogs.com/dolphin0520/p/3920385.html

一.wait()、notify()和notifyAll()

  1. import java.util.PriorityQueue;
  2.  
  3. public class QueueTest {
  4. private int queueSize = 10;
  5. private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);
  6.  
  7. public static void main(String[] args) {
  8. QueueTest test = new QueueTest();
  9. Producer producer = test.new Producer();
  10. Consumer consumer = test.new Consumer();
  11.  
  12. producer.start();
  13. consumer.start();
  14. }
  15.  
  16. ////////////////////////////////////////////
  17. class Producer extends Thread {
  18. @Override
  19. public void run() {
  20. while (true) {
  21. // wait()方法 notify()方法 必须在同步块或者同步方法中进行(synchronized块或者synchronized方法)
  22. synchronized (queue) {
  23. //队列满的时候 锁
  24. while (queue.size() == queueSize) {
  25. try {
  26. System.out.println("队列满,等待有空余空间");
  27.  
  28. //调用某个对象的wait()方法能让当前线程阻塞,并且当前线程必须拥有此对象的monitor(即锁)
  29. //调用某个对象的wait()方法,相当于让当前线程交出此对象的monitor,然后进入等待状态,等待后续再次获得此对象的锁
  30. //(Thread类中的sleep方法使当前线程暂停执行一段时间,从而让其他线程有机会继续执行,但它并不释放对象锁);
  31. queue.wait();
  32. } catch (InterruptedException e) {
  33. e.printStackTrace();
  34. queue.notify();
  35. }
  36. }
  37. queue.offer(1); // 每次插入一个元素
  38.  
  39. //调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程,如果有多个线程都在等待这个对象的monitor,则只能唤醒其中一个线程;
  40. //调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程;
  41. //notify()和notifyAll()方法只是唤醒等待该对象的monitor的线程,并不决定哪个线程能够获取到monitor。
  42. //一个线程被唤醒不代表立即获取了对象的monitor,只有等调用完notify()或者notifyAll()并退出synchronized块,释放对象锁后,其余线程才可获得锁执行。
  43. queue.notify();
  44. System.out.println("向队列取中插入一个元素,队列剩余空间:" + (queueSize - queue.size()));
  45. }
  46. }
  47. }
  48. }
  49. ////////////////////////////////////////////
  50. class Consumer extends Thread {
  51. @Override
  52. public void run() {
  53. while (true) {
  54. synchronized (queue) {
  55. //队列为空时 锁
  56. while (queue.size() == 0) {
  57. try {
  58. System.out.println("队列空,等待数据");
  59. queue.wait();
  60. } catch (InterruptedException e) {
  61. e.printStackTrace();
  62. queue.notify();
  63. }
  64. }
  65. queue.poll(); // 每次移走队首元素
  66. queue.notify();
  67. System.out.println("从队列取走一个元素,队列剩余" + queue.size() + "个元素");
  68. }
  69. }
  70. }
  71. }
  72. }

二.Condition

  Condition是在java 1.5中才出现的,它用来替代传统的Object的wait()、notify()实现线程间的协作,相比使用Object的wait()、notify(),使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。

因此通常来说比较推荐使用Condition,在阻塞队列那一篇博文中就讲述到了,阻塞队列实际上是使用了Condition来模拟线程间协作。

  • Condition是个接口,基本的方法就是await()和signal()方法;
  • Condition依赖于Lock接口,生成一个Condition的基本代码是lock.newCondition()
  • 调用Condition的await()和signal()方法,都必须在lock保护之内,就是说必须在lock.lock()和lock.unlock之间才可以使用

  Conditon中的await()对应Object的wait();

  Condition中的signal()对应Object的notify();

  Condition中的signalAll()对应Object的notifyAll()。

  1. import java.util.PriorityQueue;
  2. import java.util.concurrent.locks.Condition;
  3. import java.util.concurrent.locks.Lock;
  4. import java.util.concurrent.locks.ReentrantLock;
  5.  
  6. public class Test {
  7.  
  8. private int queueSize = 10;
  9. private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);
  10. private Lock lock = new ReentrantLock();
  11. private Condition notFull = lock.newCondition();
  12. private Condition notEmpty = lock.newCondition();
  13.  
  14. public static void main(String[] args) {
  15. Test test = new Test();
  16. Producer producer = test.new Producer();
  17. Consumer consumer = test.new Consumer();
  18.  
  19. producer.start();
  20. consumer.start();
  21. }
  22.  
  23. class Consumer extends Thread {
  24.  
  25. @Override
  26. public void run() {
  27.  
  28. while (true) {
  29. //调用Condition的await()和signal()方法,都必须在lock保护之内,就是说必须在lock.lock()和lock.unlock之间才可以使用
  30. lock.lock();
  31. try {
  32. while (queue.size() == 0) {
  33. try {
  34. System.out.println("队列空,等待数据");
  35. notEmpty.await();
  36. } catch (InterruptedException e) {
  37. e.printStackTrace();
  38. }
  39. }
  40. queue.poll(); // 每次移走队首元素
  41. notFull.signal();
  42. System.out.println("从队列取走一个元素,队列剩余" + queue.size() + "个元素");
  43. } finally {
  44. lock.unlock();
  45. }
  46. }
  47.  
  48. }
  49.  
  50. }
  51.  
  52. class Producer extends Thread {
  53. @Override
  54. public void run() {
  55.  
  56. while (true) {
  57. lock.lock();
  58. try {
  59. while (queue.size() == queueSize) {
  60. try {
  61. System.out.println("队列满,等待有空余空间");
  62. notFull.await();
  63. } catch (InterruptedException e) {
  64. e.printStackTrace();
  65. }
  66. }
  67. queue.offer(1); // 每次插入一个元素
  68. notEmpty.signal();
  69. System.out.println("向队列取中插入一个元素,队列剩余空间:" + (queueSize - queue.size()));
  70. } finally {
  71. lock.unlock();
  72. }
  73. }
  74. }
  75. }
  76. }

thread_线程间协作:wait、notify、notifyAll和Condition的更多相关文章

  1. 进程间协作---wait,notify,notifyAll

    转自牛客网的一篇评论,解释的十分详细 在 Java 中,可以通过配合调用 Object 对象的 wait() 方法和 notify()方法或 notifyAll() 方法来实现线程间的通信.在线程中调 ...

  2. Java并发编程:线程间协作的两种方式:wait、notify、notifyAll和Condition

    Java并发编程:线程间协作的两种方式:wait.notify.notifyAll和Condition 在前面我们将了很多关于同步的问题,然而在现实中,需要线程之间的协作.比如说最经典的生产者-消费者 ...

  3. Java并发编程(十三)线程间协作的两种方式:wait、notify、notifyAll和Condition

    在现实中,需要线程之间的协作.比如说最经典的生产者-消费者模型:当队列满时,生产者需要等待队列有空间才能继续往里面放入商品,而在等待的期间内,生产者必须释放对临界资源(即队列)的占用权.因为生产者如果 ...

  4. 多线程之线程间协作的两种方式:wait、notify、notifyAll和Condition

    Java并发编程:线程间协作的两种方式:wait.notify.notifyAll和Condition 在前面我们将了很多关于同步的问题,然而在现实中,需要线程之间的协作.比如说最经典的生产者-消费者 ...

  5. 14 线程间协作的两种方式:wait、notify、notifyAll和Condition

    原文链接:http://www.cnblogs.com/dolphin0520/p/3920385.html 在前面我们将了很多关于同步的问题,然而在现实中,需要线程之间的协作.比如说最经典的生产者- ...

  6. 19、Java并发编程:线程间协作的两种方式:wait、notify、notifyAll和Condition

    Java并发编程:线程间协作的两种方式:wait.notify.notifyAll和Condition 在前面我们将了很多关于同步的问题,然而在现实中,需要线程之间的协作.比如说最经典的生产者-消费者 ...

  7. Java并发--线程间协作的两种方式:wait、notify、notifyAll和Condition

    在前面我们将了很多关于同步的问题,然而在现实中,需要线程之间的协作.比如说最经典的生产者-消费者模型:当队列满时,生产者需要等待队列有空间才能继续往里面放入商品,而在等待的期间内,生产者必须释放对临界 ...

  8. 线程间协作:wait、notify、notifyAll

    线程间协作:wait.notify.notifyAll 在 Java 中,可以通过配合调用 Object 对象的 wait() 方法和 notify()方法或 notifyAll() 方法来实现线程间 ...

  9. 线程间协作的两种方式:wait、notify、notifyAll和Condition

    转载自海子: 在前面我们将了很多关于同步的问题,然而在现实中,需要线程之间的协作.比如说最经典的生产者-消费者模型:当队列满时,生产者需要等待队列有空间才能继续往里面放入商品,而在等待的期间内,生产者 ...

随机推荐

  1. Email the output of a concurrent program as Attachment

    This article illustrates the steps to be followed to Email a concurrent program's output. Write a pr ...

  2. Unity3D 避免玩家作弊

    如果你的Unity项目快上线了,我强烈建议你看一下Anti-Cheat这个插件.因为IOS和Android分别越狱和Root后玩家可以使用 @八门神器 @烧饼修改器 等一些列作弊的软件来修改游戏内存, ...

  3. PostgreSQL配置文件--实时统计

    7 实时统计 RUNTIME STATISTICS 7.1 Query/Index Statistics Collector 下面的参数控制是否搜集特定的数据库运行统计数据 7.1.1 track_a ...

  4. 二十四种设计模式:策略模式(Strategy Pattern)

    策略模式(Strategy Pattern) 介绍定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换.本模式使得算法的变化可独立于使用它的客户. 示例有一个Message实体类,对它的操作有 ...

  5. DESede对称加密算法工具类

    利用Cipher的核心功能,自己封装了一个加密解密的工具类,可以直接使用.在使用之前需要先下载commons-codec-1.9.jar,并导入项目. 工具类如下: package com.pcict ...

  6. C#-遍历datatable的几种方法

    遍历datatable的方法2009-- :02方法一: DataTable dt = dataSet.Tables[]; ; i < dt.Rows.Count ; i++) { string ...

  7. (转)如何在maven环境中设置JVM参数

    有时候我们需要设定maven环境下的JVM参数,以便通过maven执行的命令或启动的系统能得到它们需要的参数设定.比如:当我们使用jetty:run启动jetty服务器时,在进行热部署时会经常发生:J ...

  8. ActiveMQ订阅模式持久化实现

    实现步骤:1.配置发送xml,applicationContext-send.xml <?xml version="1.0" encoding="UTF-8&quo ...

  9. FastIV图像处理

    新建一图像处理算法群,主要讨论图像处理与计算机视觉中的快速算法及其工程实现. 群号码:322687422

  10. Python函数:使用谷歌翻译翻译英语字符串

    代码是同事写的,我把它单独抠出来,可以作为工具函数使用.当然,性能还是个问题,有待解决. import random import cookielib import urllib import url ...