1. import java.util.concurrent.locks.Condition;
   
2. import java.util.concurrent.locks.Lock;
   
3. import java.util.concurrent.locks.ReentrantLock;
   
4. 
   
5. class BoundedBuffer {
   
6.    final Lock lock = new ReentrantLock();
   
7.    final Condition notFull  = lock .newCondition();
   
8.    final Condition notEmpty = lock .newCondition();
   
9. 
   
10.    final Object[] items = new Object[100];
    
11.    int putptr, takeptr , count ;
    
12. 
    
13.    public void put(Object x) throws InterruptedException {
    
14.      lock.lock();
    
15.      try {
    
16.       
    
17.          items[putptr ] = x;
    
18.          if (++putptr == items.length) putptr = 0;
    
19.          ++ count;
    
20.          notEmpty.signal();
    
21.       } finally {
    
22.         lock.unlock();
    
23.      }
    
24.    }
    
25. 
    
26.    public Object take() throws InterruptedException {
    
27.       lock.lock();
    
28.       try {
    
29.        while (count == 0)
    
30.          notEmpty.await();
    
31.        Object x = items[takeptr];
    
32.        if (++takeptr == items.length) takeptr = 0;
    
33.        -- count;
    
34.        notFull.signal();
    
35.        return x;
    
36.      } finally {
    
37.        lock.unlock();
    
38.      }
    
39.    }
    

复制代码

这是视频中生产者和消费者的问题，这段代码打印我复制后用Eclipse运行的结果是每生产100只后再消费100只；
可是如果是这样的话，不是应该改成while (count == items.length)
{notEmpty.signal();
notFull.await();}
和
while(count==0)
    {notFull.signal();
     notEmpty.await();}吗？？我这样改后运行了一下，结果是一样的。但是上面那样写我想不太明白。求解答。

第一个try后没用判断等待条件，认为让程序等待试一下呢