java.util.concurrent.locks.Condition如何工作？

Question

阅读有关该java.util.concurrent.locks.Condition接口的Java 8文档,给出以下示例:

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

所以我的主要问题是:条件如何运作？

1. 是否在开始等待时释放锁定？(notFull.await()例如)？
2. 不同的线程可以获得相同的锁定并移动直到它成为signal()一个条件,唤醒其他线程吗？
3. 我认为这个例子会导致死锁,因为如果一个线程正在等待缓冲区不为空并且它还没有释放锁,那么另一个线程如何获取锁,清空缓冲区,signal()现在满足条件,如果线程没有释放锁等待缓冲区未满,则释放锁？

这些是初学者的问题.请帮帮我.

谢谢.

Answer 1

1. 是的，这是正确的，一旦等待条件，它就会释放锁。await/signal/signalAll实际上具有相同的行为wait/notify/notifyAll
2. 否 ReentrantLock 是一种排他锁，因此只有一个线程可以获取该锁。
3. 见#1。当一个线程调用signal或 时signalAll，它分别释放一个或所有等待相应Condition的线程，这样该线程或那些线程将有资格再次获取锁。但是现在锁仍然由调用的线程拥有，signal或者signalAll直到它通过调用显式释放锁lock.unlock。然后已经/已经被释放的线程将能够再次尝试获取锁，可以获取锁的线程将能够再次检查条件（这次我的意思是条件count == items.length或count == 0在这个例子中） , 如果没问题，它将继续，否则它将await再次释放锁以使其可用于另一个线程。