Poniższy kod pochodzi zJavaDoc zCondition:

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

Wyobraź sobie 2 wątki,Konsument iProducent, jeden używatake, jedenput na jednym wystąpieniuBoundedBuffer.

PowiedzmyKonsument idzie pierwszy, biegnietake() w której zamykalock i teraz zapętla sięnotEmpty.await();.

Jak teraz możeszProducent ewentualnie dostać się doput() metoda przeszła blokowanielock, który jest już w posiadaniuKonsument?

Czego mi tu brakuje? Jestlock „tymczasowo zwolniony”, podczas gdy wątek czeka na jeden ze swoich warunków? A co robireentrancy dokładnie z zamkiem?