这是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();
     }
   }
}

这个已经想通了，发个链接
http://bbs.itheima.com/thread-136484-1-1.html

黑马-蒋振军 发表于 2014-8-7 18:57

PS，你这个代码编辑器怎么设置的？我怎么没找到

yuli2039 发表于 2014-8-7 18:27
我也刚学了这个！我觉得这里 这一节主要强调的是多线程的安全问题，一进一出两个线程同时操作一个数据，可 ...

我有强迫症，不懂的东西一点没接触就算了，接触了还没搞懂就很不舒服了

黑马-蒋振军 发表于 2014-8-7 18:57

额，可能是我没表达清楚，这个我明白，我说的是资源数量不止一个，比如有一百个蛋糕的货架，货架不满生产者就可以生产，货架不空消费者就可以消费

1. import java.util.concurrent.locks.*;
   
2. 
   
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. }

复制代码

我也刚学了这个！我觉得这里 这一节主要强调的是多线程的安全问题，一进一出两个线程同时操作一个数据，可能产生安全问题，知道这个锁怎么用就可以了！不必纠结于应用实例。