黑马程序员技术交流社区

标题: 谁有多生产者多消费者生产消费多个蛋糕的实例 [打印本页]
作者: wnmmp    时间: 2014-8-7 18:03
标题: 谁有多生产者多消费者生产消费多个蛋糕的实例
本帖最后由 wnmmp 于 2014-8-7 23:09 编辑

这是JDK1.6 API里Condition接口里面多生产者多消费者生产消费多个蛋糕的模型，看了好久没有看懂，应该是没有具体对象，所以比较抽象，毕老师说这个开发时复制完拿来就能用，谁有这个代码的应用实例？
class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition();
   final Condition notEmpty = lock.newCondition();

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length)
         notFull.await();
       items[putptr] = x;
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally {
       lock.unlock();
     }
   }

   public Object take() throws InterruptedException {
     lock.lock();
     try {
       while (count == 0)
         notEmpty.await();
       Object x = items[takeptr];
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally {
       lock.unlock();
     }
   }
}
作者: yuli2039    时间: 2014-8-7 18:27
我也刚学了这个！我觉得这里 这一节主要强调的是多线程的安全问题，一进一出两个线程同时操作一个数据，可能产生安全问题，知道这个锁怎么用就可以了！不必纠结于应用实例。
作者: 黑马-蒋振军    时间: 2014-8-7 18:57
  1. import java.util.concurrent.locks.*;

  3. //jdk 1.5版本升级版
  4. class ProducerConsumerDemo1
  5. {
  6.         public static void main(String[] args)
  7.         {
  8.                 Resource r=new Resource();
  9.                 Producer p=new Producer(r);
  10.                 Consumer c=new Consumer(r);
  11.                 Thread t1=new Thread(p);
  12.                 Thread t2=new Thread(p);
  13.                 Thread t3=new Thread(c);
  14.                 Thread t4=new Thread(c);
  15.                 t1.start();
  16.                 t2.start();
  17.                 t3.start();
  18.                 t4.start();
  19.                 /*
  20.                 new Thread(new Producer(r)).start();
  21.                 new Thread(new Producer(r)).start();
  22.                 new Thread(new Consumer(r)).start();
  23.                 new Thread(new Consumer(r)).start();
  24.                 */
  25.         }
  26. }
  27. class Resource
  28. {
  29.         private String name;
  30.         private int count=0;
  31.         private Boolean flag=false;
  32.         private ReentrantLock lock=new ReentrantLock();
  33.         private Condition conditiona=lock.newCondition();
  34.         private Condition conditionb=lock.newCondition();
  35.         public void setName(String name)throws Exception{
  36.                 lock.lock();
  37.                 try
  38.                 {
  39.                         while(flag){
  40.                                 conditiona.await();
  41.                         }
  42.                         this.name=name+count++;
  43.                         System.out.println(Thread.currentThread().getName()+"...生产者"+this.name+"++");
  44.                         flag=true;
  45.                         conditionb.signal();
  46.                 }finally{
  47.                         lock.unlock();
  48.                 }
  49.         }
  50.         public void  out() throws Exception{
  51.                 lock.lock();
  52.                 try
  53.                 {
  54.                         while(!flag){
  55.                                 conditionb.await();
  56.                         }
  57.                         System.out.println(Thread.currentThread().getName()+"......消费者..."+this.name+"====");
  58.                         flag=false;
  59.                         conditiona.signal();
  60.                 }finally{
  61.                         lock.unlock();
  62.                 }
  63.         }
  64. }
  65. class Producer implements Runnable
  66. {
  67.         private Resource r;
  68.         Producer(Resource r){
  69.                 this.r=r;
  70.         }
  71.         public void run(){
  72.                 while(true){
  73.                         try
  74.                         {
  75.                                 r.setName("+商品+");
  76.                         }
  77.                         catch (Exception e)
  78.                         {
  79.                         }
  80.                        
  81.                 }
  82.         }
  83. }
  84. class Consumer implements Runnable
  85. {
  86.         private Resource r;
  87.         Consumer(Resource r){
  88.                 this.r=r;
  89.         }
  90.         public void run(){
  91.                 while(true){
  92.                         try
  93.                         {
  94.                                 r.out();
  95.                         }
  96.                         catch (Exception e)
  97.                         {
  98.                         }
  99.                 }
  100.         }
  101. }
复制代码
作者: wnmmp    时间: 2014-8-7 23:06
黑马-蒋振军 发表于 2014-8-7 18:57

额，可能是我没表达清楚，这个我明白，我说的是资源数量不止一个，比如有一百个蛋糕的货架，货架不满生产者就可以生产，货架不空消费者就可以消费
作者: wnmmp    时间: 2014-8-7 23:10
yuli2039 发表于 2014-8-7 18:27
我也刚学了这个！我觉得这里 这一节主要强调的是多线程的安全问题，一进一出两个线程同时操作一个数据，可 ...

我有强迫症，不懂的东西一点没接触就算了，接触了还没搞懂就很不舒服了
作者: wnmmp    时间: 2014-8-7 23:40
黑马-蒋振军 发表于 2014-8-7 18:57

PS，你这个代码编辑器怎么设置的？我怎么没找到
作者: wnmmp    时间: 2014-8-8 23:45
这个已经想通了，发个链接
http://bbs.itheima.com/thread-136484-1-1.html



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