黑马程序员技术交流社区

标题: jdk1.5等待唤醒机制——多消费多生产 [打印本页]
作者: @白纸嘿字@    时间: 2015-8-26 21:31
标题: jdk1.5等待唤醒机制——多消费多生产
本帖最后由 @白纸嘿字@ 于 2015-8-28 11:04 编辑

自己写的代码，报错了！可检查了好多遍，实在是看不出哪里错了？

还有一个，就是自己始终对Condition一知半解，我new出来一个Condition类型对象，用它监视器方法时，我怎么知道，是本方的，还是对方的监视器方法呢？
  1. package com.itheima.thread;

  3. import java.util.concurrent.locks.*;

  5. class SingleResource {
  6.         private String name;
  7.         private int count = 1;
  8.         // 定义标记，用于解决生产者和消费者之间的"和平相处"
  9.         private boolean flag;
  10.         Lock l = new ReentrantLock();
  11.         Condition pro = l.newCondition();
  12.         Condition con = l.newCondition();

  14.         SingleResource(String name) {
  15.                 this.name = name;
  16.         }

  18.         // 生产者生产资源
  19.         public synchronized void moreProducer_Pro() {
  20.                 l.lock();
  21.                 while (true) {
  22.                         try {
  23.                                 while (flag) {
  24.                                         try {

  26.                                                 pro.await();
  27.                                         } catch (InterruptedException e) {
  28.                                         }
  29.                                 }
  30.                                 count++;
  31.                                 System.out.println("MoreProduce_NO." + count + "_" + name);

  33.                                 flag = true;
  34.                                 con.signal();
  35.                         } finally {
  36.                                 l.unlock();
  37.                         }
  38.                 }

  40.         }

  42.         // 消费者消费资源
  43.         public synchronized void moreConsumer_Con() {
  44.                 l.lock();
  45.                 while (true) {
  46.                         try {
  47.                                 while (!flag) {
  48.                                         try {

  50.                                                 con.await();
  51.                                         } catch (InterruptedException e) {

  53.                                         }
  54.                                 }
  55.                                 System.out.println("\t" + "MoreConsume_NO." + count + "_"
  56.                                                 + name);

  58.                                 flag = false;
  59.                                 pro.signal();

  61.                         } finally {
  62.                                 l.unlock();
  63.                         }
  64.                 }

  66.         }
  67. }

  69. class MoreProducer implements Runnable {
  70.         private SingleResource r;

  72.         MoreProducer(SingleResource r) {
  73.                 this.r = r;
  74.         }

  76.         public void run() {
  77.                 r.moreProducer_Pro();
  78.         }
  79. }

  81. class MoreConsumer implements Runnable {
  82.         private SingleResource r;

  84.         MoreConsumer(SingleResource r) {
  85.                 this.r = r;
  86.         }

  88.         public void run() {
  89.                 r.moreConsumer_Con();
  90.         }
  91. }

  93. public class MoreProducerConsumerDemo {

  95.         public static void main(String[] args) {
  96.                 SingleResource r = new SingleResource("Bread");
  97.                 MoreProducer p = new MoreProducer(r);
  98.                 MoreConsumer c = new MoreConsumer(r);
  99.                 Thread t0 = new Thread(p);
  100.                 Thread t1 = new Thread(p);
  101.                 Thread t2 = new Thread(p);
  102.                 Thread t3 = new Thread(c);
  103.                 Thread t4 = new Thread(c);
  104.                 Thread t5 = new Thread(c);
  105.                 t0.start();
  106.                 t1.start();
  107.                 t2.start();
  108.                 t3.start();
  109.                 t4.start();
  110.                 t5.start();
  111.         }
  112. }

  114. 结果：
  115. MoreProduce_NO.2_Bread
  116. Exception in thread "Thread-1" java.lang.IllegalMonitorStateException
  117.         at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:127)
  118.         at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1175)
  119.         at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:431)
  120.         at com.itheima.thread.SingleResource.moreProducer_Pro(MoreProducerConsumerDemo.java:36)
  121.         at com.itheima.thread.MoreProducer.run(MoreProducerConsumerDemo.java:77)
  122.         at java.lang.Thread.run(Thread.java:619)
复制代码
作者: 漠陌    时间: 2015-8-26 21:32
不明觉厉
作者: @白纸嘿字@    时间: 2015-8-26 21:39
漠陌 发表于 2015-8-26 21:32
不明觉厉

什么意思？我语文，从小就不好！
作者: wyd1    时间: 2015-8-26 21:52
死锁，只生产了2个面包
作者: @白纸嘿字@    时间: 2015-8-26 22:46
wyd1 发表于 2015-8-26 21:52
死锁，只生产了2个面包

怎么死的？
作者: pengbeilin    时间: 2015-8-26 22:55
本帖最后由 pengbeilin 于 2015-8-26 22:56 编辑

---------看看啊
作者: pengbeilin    时间: 2015-8-26 23:10
帮你改了改~ 你自己对照看看吧~
  1. import java.util.concurrent.locks.*;

  3. class SingleResource {
  4.         private String name;
  5.         private int count = 1;
  6.         // 定义标记，用于解决生产者和消费者之间的"和平相处"
  7.         private boolean flag;
  8.         Lock l = new ReentrantLock();
  9.         Condition pro = l.newCondition();
  10.         Condition con = l.newCondition();

  12.         SingleResource(String name) {
  13.                 this.name = name;
  14.         }

  16.         // 生产者生产资源
  17.                 //把你的两个函数都改了一下！！ 你自己对照一下~
  18.         public  void moreProducer_Pro() {
  19.                 l.lock();
  20.                                while (flag)
  21.                                         try {

  23.                                                 pro.await();
  24.                                         } catch (InterruptedException e) {
  25.                                         }
  26.                               
  27.                                 count++;
  28.                                 System.out.println("MoreProduce_NO." + count + "_" + name);

  30.                                 flag = true;
  31.                                 con.signal();
  32.                        
  33.                                 l.unlock();

  35.         }

  37.         // 消费者消费资源   
  38.         public  void moreConsumer_Con() {
  39.                 l.lock();
  40.                     while (!flag)
  41.                                         try {

  43.                                                 con.await();
  44.                                         } catch (InterruptedException e) {

  46.                                         }
  47.                           
  48.                                 System.out.println("\t" + "MoreConsume_NO." + count + "_"
  49.                                                 + name);

  51.                                 flag = false;
  52.                                 pro.signal();
  53.                      
  54.                          l.unlock();
  55.                        
  56.                

  58.         }
  59. }

  61. class MoreProducer implements Runnable {
  62.         private SingleResource r;

  64.         MoreProducer(SingleResource r) {
  65.                 this.r = r;
  66.         }

  68.         public void run() {
  69.                         while(true)//循环放到这里来了
  70.                 r.moreProducer_Pro();
  71.         }
  72. }

  74. class MoreConsumer implements Runnable {
  75.         private SingleResource r;

  77.         MoreConsumer(SingleResource r) {
  78.                 this.r = r;
  79.         }

  81.         public void run() {
  82.                         while(true)//循环放到这里来了
  83.                 r.moreConsumer_Con();
  84.         }
  85. }

  87. public class demo08{

  89.         public static void main(String[] args) {
  90.                 SingleResource r = new SingleResource("Bread");
  91.                 MoreProducer p = new MoreProducer(r);
  92.                 MoreConsumer c = new MoreConsumer(r);
  93.                 Thread t0 = new Thread(p);
  94.                 Thread t1 = new Thread(p);
  95.                 Thread t2 = new Thread(p);
  96.                 Thread t3 = new Thread(c);
  97.                 Thread t4 = new Thread(c);
  98.                 Thread t5 = new Thread(c);
  99.                 t0.start();
  100.                 t1.start();
  101.                 t2.start();
  102.                 t3.start();
  103.                 t4.start();
  104.                 t5.start();
  105.         }
  106. }
复制代码
作者: @白纸嘿字@    时间: 2015-8-27 00:03
pengbeilin 发表于 2015-8-26 23:10
帮你改了改~ 你自己对照看看吧~

对喽！你能不能再回答一下这个问题：我new出来一个Condition类型对象，用它监视器方法时，我怎么知道，是本方的，还是对方的监视器方法呢？
作者: @白纸嘿字@    时间: 2015-8-27 00:09
pengbeilin 发表于 2015-8-26 23:10
帮你改了改~ 你自己对照看看吧~


不对啊，没有finally，万一出现异常，就永远都不会释放锁了！
作者: pengbeilin    时间: 2015-8-27 00:37
本帖最后由 pengbeilin 于 2015-8-27 09:46 编辑



程序执行，首先生产线程进来拿锁，判断标记如果为假，就下去直接生产了，生产完之后 改变标记为真，并唤醒消费线程(有了那个监听器之后就只会唤醒对方线程而不会唤醒本方线程)，消费线程被唤醒，判断标记为真就进去了，没有执行await，执行消费商品，并把标记改为了假，然后通过标记唤醒对方线程，就是这样子。
      
作者: pengbeilin    时间: 2015-8-27 00:38
@白纸嘿字@ 发表于 2015-8-27 00:09
不对啊，没有finally，万一出现异常，就永远都不会释放锁了！

- -自己加上去就好了~
作者: @白纸嘿字@    时间: 2015-8-27 01:03
pengbeilin 发表于 2015-8-27 00:38
- -自己加上去就好了~

怎么加？
作者: pengbeilin    时间: 2015-8-27 09:06
本帖最后由 pengbeilin 于 2015-8-27 09:42 编辑
  1. public  void moreProducer_Pro() {
  2.                                                          l.lock();try{        //这里try
  3.                          while (flag)
  4.                                   try { pro.await();} catch (InterruptedException e) {}
  5.                                 count++;
  6.                                 System.out.println("MoreProduce_NO." + count + "_" + name);

  8.                                 flag = true;
  9.                                 con.signal();
  10.                                                                 }
  11.                        finally{//这finally
  12.                                 l.unlock();
  13.                                                   }
  14.         }

  16.         // 消费者消费资源   
  17.         public  void moreConsumer_Con() {
  18.                       l.lock();
  19.                                 try{//这里try
  20.                     while (!flag)
  21.                      try { con.await();} catch (InterruptedException e) {}   
  22.                        System.out.println("\t" + "MoreConsume_NO." + count + "_" + name);
  23.                                 flag = false;
  24.                                 pro.signal();
  25.                                                         }
  26.                                         finally{//这里finally
  27.                                                          l.unlock();
  28.                                                    }
  29.                

  31.         }
复制代码





欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2