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

转自 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. IIS服务器80端口却已被占用的问题

    一.问题背景 在IIS中发布一个asp网站,发现无法使用80端口,错误为“无法启动该网站.其它网站可能正在使用同一端口”.但其实IIS的其它网站已经没有使用该端口了.这就需要设计到,找到那个进程占用这 ...

  2. Xcode8从相册选图片

    使用Xcode8写自己的东西有一段时间了,在使用Xcode8编程时不得不说我特别喜欢改后的默认字体,哈哈,当然默认字体是可以调回去的,只不过默认的字体感觉看起来比以前舒服了,毕竟不会像之前那么”字正腔 ...

  3. 支持向量机(SVM)介绍

    一.了解支持向量机   支持向量机(support vector machings, SVM) 是一种二分类模型,其基本模型定义为特征空间上的间隔最大的线性分类器,其学习策略便是间隔最大化,最终可转化 ...

  4. 创建maven web项目无法创建sec目录

    创建maven web项目无法创建sec目录 解决方法:-DarchetypeCatalog=internal

  5. [转]Sql server 大数据量分页存储过程效率测试附代码

    本文转自:http://www.cnblogs.com/lli0077/archive/2008/09/03/1282862.html 在项目中,我们经常遇到或用到分页,那么在大数据量(百万级以上)下 ...

  6. iOS:网页视图控件UIWebView的详解

    网页视图控件:UIWebView 功能:它是继承于UIView的,是一个内置的浏览器控件,以用来浏览从网络下载下来的网页或者本地上加载下来的文档. 枚举: //网页视图导航类型 typedef NS_ ...

  7. 二、ELKStack集群架构设计

    一.ELKStack介绍与入门实践 二.Elasticsearch 集群架构图 服务器配置:Centos6.6 x86_64 CPU:1核心 MEM:2G (做实验,配置比较低一些) 注:这里配置el ...

  8. OpenGL ES入门09-GLSL实现常见特效 [转]

    本文转自简书,原文地址http://www.jianshu.com/p/e4a8c83cd37 本文是关于OpenGL ES的系统性学习过程,记录了自己在学习OpenGL ES时的收获. 这篇文章的目 ...

  9. c# string与String区别

    [C#] String与string的区别:供参考 转自:https://www.cnblogs.com/rosesmall/p/8351808.html C#是区分大小写的,但是我却发现C#中同时存 ...

  10. C# 秒数转日期_由秒数得到日期几天几小时_当前日期时间,转换为秒

    ///<summary> ///由秒数得到日期几天几小时... ///</summary ///<param name="t">秒数</para ...