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

转自 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. oracle 查看执行最慢 sql

    查询执行最慢的sql select * from (select sa.SQL_TEXT, sa.SQL_FULLTEXT, sa.EXECUTIONS "执行次数", round ...

  2. hive删除列

    hive中删除列时没有与mysql语句alter table <table> drop column <col>对应的语句. 然而依然可以完成此功能:使用ALTER TABLE ...

  3. PostgreSQL配置文件--日志和错误

    6 错误操作和日志 ERROR REPORTING AND LOGGING 6.1 日志写到哪里 Where to Log 6.1.1 log_destination 字符串 默认: log_dest ...

  4. MySQL建表时,日期时间类型选择

    MySQL(5.5)所支持的日期时间类型有:DATETIME. TIMESTAMP.DATE.TIME.YEAR. 几种类型比较如下: 日期时间类型 占用空间 日期格式 最小值 最大值 零值表示  D ...

  5. Java实现Redis pipeline比较

    开始实验这个,是因为Redis实战.pdf上面有例子. 上面用的是 org.jredis包,可是发现这个包不在maven的公共仓库里.需要先下载然后放在本地,导入maven依赖.详见: http:// ...

  6. PowerShell中的一个switch的例子

    在这个例子中, 应该注意 Switch语句里对数字范围条件的使用 break的使用 字符串的拼接 数组的声明   ) foreach ($element in $array) { switch($el ...

  7. 应用LR监控Apache性能

    1)对Apache服务器中的http.conf进行如下配置修改Apache中Httpd.conf文件,添加如下代码(该文件中都有,只要取消注释就好了)<Location /server-stat ...

  8. maven自动打包到tomcat 8

    <build> <finalName>maven-project</finalName> <plugins> <plugin> <gr ...

  9. 03-hibernate注解-关系映射级别注解-一对一

    实体之间的映射关系 一对一:一个公民对应一个身份证号码 一对多(多对一):一个人可以有多个银行账号 多对多:一个学生有多个老师,一个老师有多个学生. 一对一单向外键关联 @OneToOne(casca ...

  10. loadrunner参数使用总结

    使用loadrunner进行性能测试,在准备脚本阶段参数是不可避免要使用到的,现把参数的各种设置取值方式总结一下,方便日后查阅: update value on Sequential顺序取值下的取值结 ...