黑马程序员技术交流社区

标题: 关于多生产者、多消费者 停止程序问题------>求大神指点 [打印本页]
作者: 小歪    时间: 2014-4-20 22:05
标题: 关于多生产者、多消费者 停止程序问题------>求大神指点

关于多生产者、多消费者  停止程序问题




        看完毕老师的多生产者和多消费者后，也写出了代码，但是代码中一直在生产、消费状态，现在如果加入条件使其只生产、消费100个商品后顺利结束程序，有什么好方法，毕老师后面讲的让线程强制启动避免程序挂起，我也想试着加入到多生产、多消费程序中，却不知道从何下手，可能是本人技术不到家，最后听一位朋友建议在生产者和消费者中分别加入了静态（static）的计数器（count）才算解决，可毕竟静态（static）对象是无法在内存中清除的，有没有更好的方法，哪位大神教教我。

具体代码如下：
  1. package ClassPackage;

  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;

  7. /*
  8. 利用JDK1.5新特性 解决   “多生产者、多消费者问题”
  9.          1、实现多个个线程同时生产、多个线程同时消费状态
  10.          2、不能出现共享资源安全问题
  11.          3、不能出现死锁状态
  12.          4、唤醒线程时，只能唤醒对方线程，不可唤醒本方线程
  13.          5、生产、消费100个产品后，程序结束
  14. */

  16. class  Resource{   //共享资源类
  17.         private String obj;   //当前操作资源对象
  18.         private int count=1 ;                //资源
  19.         private boolean flag=false;  
  20.        
  21.         public int getCount()
  22.         {
  23.                 return count;
  24.         }
  25.         //一把锁，两个线程池
  26.         private Lock lock=new ReentrantLock();  
  27.         private  Condition  con_pro=lock.newCondition();
  28.         private  Condition  con_con=lock.newCondition();
  29.        
  30.         public void set(String user)
  31.         {
  32.                
  33.                         lock.lock();
  34.                         try {
  35.                                 while(flag)
  36.                                 {
  37.                                         con_pro.await();
  38.                                 }
  39.                                                 this.obj=user;
  40.                                                 System.out.println(Thread.currentThread().getName()+":"+obj+"---->生产商品"+count);
  41.                                                 flag=true;
  42.                                                 con_con.signal(); //唤醒消费者线程池中第一个线程
  43.                                         } catch (Exception e) {
  44.                                                 e.printStackTrace();
  45.                                                
  46.                                 }finally{
  47.                                         lock.unlock();          //无论是否出现异常    最后必须放开锁
  48.                                 }
  49.                
  50.         }
  51.        
  52.         public void get(String obj)
  53.         {
  54.                
  55.                         lock.lock();
  56.                         try {
  57.                                 while(!flag)
  58.                                 {
  59.                                         con_con.await();
  60.                                 }
  61.                                         System.out.println(Thread.currentThread().getName()+":"+obj+"--------------->消费商品"+count++);
  62.                                         flag=false;
  63.                                         con_pro.signal();//唤醒生产者线程池中第一个线程
  64.                                 } catch (Exception e) {
  65.                                         e.printStackTrace();
  66.                                 }finally{
  67.                                         lock.unlock();                 //无论是否出现异常    最后必须放开锁
  68.                                 }
  69.                 }
  70.         }


  73. class Producer implements Runnable
  74. {
  75.         static int count=0;
  76.         private Resource res;
  77.         public Producer(Resource res)
  78.         {
  79.                 this.res=res;
  80.         }
  81.         public void run() {
  82.                 while(count<100)
  83.                 {
  84.                         count++;
  85.                         res.set("生产者");
  86.                
  87.                 }
  88.                
  89.         }
  90.        
  91. }

  93. class Consumer implements Runnable
  94. {
  95.         static int count=0;
  96.         private Resource res;
  97.         int num=1;
  98.         public Consumer(Resource res)
  99.         {
  100.                 this.res=res;
  101.         }
  102.         public void run() {
  103.                 while(count<100)
  104.                 {
  105.                         count++;
  106.                         res.get("消费者");
  107.                        
  108.                 }
  109.         }
  110.        
  111. }
  112. public class Test30 {
  113.         public static void main(String args[])
  114.         {
  115.                 Resource r=new Resource();
  116.                 Producer pro=new Producer(r);
  117.                 Consumer con=new Consumer(r);
  118.                
  119.                 Thread t1=new Thread(pro);  
  120.                 Thread t2=new Thread(pro);
  121.                 //两个生产者线程、两个消费者线程
  122.                 Thread t3=new Thread(con);
  123.                 Thread t4=new Thread(con);
  124.                
  125.                 t1.start();
  126.                 t2.start();
  127.                 t3.start();
  128.                 t4.start();

  130.         }
  131. }
复制代码

运行后貌似解决了问题，但脑子里还是有点稀里糊涂：






有没有更好的方法，受教了！！！！


作者: 小歪    时间: 2014-4-20 22:08
还有就是  如果将  84行  和  85行 位置换一下，线程就又会挂起，谁帮忙讲解一下？
作者: 小歪    时间: 2014-4-21 08:06
没人知道吗？？？？
作者: osully    时间: 2014-4-21 10:11
让函数自身返回值 改成boolean 类型应该可以尝试一下
你看看下面我改了下还算符合你的要求不
应该算是解决了静态的不?

  1. package NoUseArea;

  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;

  7. /*
  8. 利用JDK1.5新特性 解决   “多生产者、多消费者问题”
  9. 1、实现多个个线程同时生产、多个线程同时消费状态
  10. 2、不能出现共享资源安全问题
  11. 3、不能出现死锁状态
  12. 4、唤醒线程时，只能唤醒对方线程，不可唤醒本方线程
  13. 5、生产、消费100个产品后，程序结束
  14. */

  16. class Resource { // 共享资源类
  17.         private String obj; // 当前操作资源对象
  18.         private int count = 0; // 资源
  19.         private boolean flag = false;

  21.         public int getCount() {
  22.                 return count;
  23.         }

  25.         // 一把锁，两个线程池
  26.         private Lock lock = new ReentrantLock();
  27.         private Condition con_pro = lock.newCondition();
  28.         private Condition con_con = lock.newCondition();

  30.         public boolean set(String user) {
  31.                 lock.lock();
  32.                 try {
  33.                         while (flag) {
  34.                                 con_pro.await();
  35.                         }
  36.                         this.obj = user;
  37.                         if (count < 100) {
  38.                                 System.out.println(Thread.currentThread().getName() + ":" + obj
  39.                                                 + "---->生产商品" + ++count);
  40.                         }
  41.                         flag = true;
  42.                         con_con.signal();
  43.                         if (count < 100)
  44.                                 return true;
  45.                         return false;
  46.                 }
  47.                 catch (Exception e) {
  48.                         e.printStackTrace();

  50.                 }
  51.                 finally {
  52.                         lock.unlock();
  53.                 }
  54.                 return false;
  55.         }

  57.        
  58.         //因为到100的时候所有线程都需要被唤醒,而且100只想被运行一次
  59.         boolean b = true;

  61.         public boolean get(String obj) {
  62.                 lock.lock();
  63.                 try {
  64.                         while (!flag) {
  65.                                 con_con.await();
  66.                         }
  67.                         if (count < 100) {
  68.                                 System.out.println(Thread.currentThread().getName() + ":" + obj
  69.                                                 + "--------------->消费商品" + count);
  70.                         }
  71.                         if (count == 100) {
  72.                                 synchronized (this) {
  73.                                         if (b) {
  74.                                                 System.out.println(Thread.currentThread().getName()
  75.                                                                 + ":" + obj + "--------------->消费商品" + count);
  76.                                                 b = false;
  77.                                                 flag = false;
  78.                                                 con_pro.signal();
  79.                                         }
  80.                                         return false;
  81.                                 }
  82.                         }
  83.                         flag = false;
  84.                         con_pro.signal();
  85.                         return true;
  86.                 }
  87.                 catch (Exception e) {
  88.                         e.printStackTrace();
  89.                 }
  90.                 finally {
  91.                         lock.unlock(); // 无论是否出现异常 最后必须放开锁
  92.                 }
  93.                 return false;
  94.         }
  95. }

  97. class Producer implements Runnable {
  98.         private Resource res;

  100.         public Producer(Resource res) {
  101.                 this.res = res;
  102.         }

  104.         public void run() {
  105.                 boolean b = res.set("生产者");
  106.                 while (b) {
  107.                         b = res.set("生产者");
  108.                 }
  109.         }

  111. }

  113. class Consumer implements Runnable {
  114.         private Resource res;

  116.         public Consumer(Resource res) {
  117.                 this.res = res;
  118.         }

  120.         public void run() {
  121.                 boolean b = res.get("消费者");
  122.                 while (b) {
  123.                         b = res.get("消费者");
  124.                 }
  125.         }

  127. }

  129. public class Test30 {
  130.         public static void main(String args[]) {
  131.                 Resource r = new Resource();
  132.                 Producer pro = new Producer(r);
  133.                 Consumer con = new Consumer(r);

  135.                 Thread t1 = new Thread(pro);
  136.                 Thread t2 = new Thread(pro);
  137.                 // 两个生产者线程、两个消费者线程
  138.                 Thread t3 = new Thread(con);
  139.                 Thread t4 = new Thread(con);

  141.                 t1.start();
  142.                 t2.start();
  143.                 t3.start();
  144.                 t4.start();

  146.         }
  147. }
复制代码




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