正如 Lock 是一种广义的内置锁，Condition 也是一种广义的内置条件队列。一个 Condition 和一个 Lock 关联在一起，就像一个条件队列和一个内置锁相关联一样。要创建一个 Condition，可以在相关联的 Lock 上调用 Lock.newCondition 方法。
正如 Lock 比内置加锁提供了更为丰富的功能，Condition 同样比内置条件队列提供了更丰富的功能：在每个锁上可存在多个等待、条件等待可以是可中断的或不可中断的、基于时限的等待，以及公平的或非公平的队列操作。
与内置条件队列不同的是，对于每个 Lock，可以有任意数量的 Condition 对象。Condition 对象继承了相关的 Lock 对象的公平性，对于公平的锁，线程会依照 FIFO 顺序从 Condition.await 中释放。
在 Condition 对象中，与 wait、notify 和 notifyAll 方法对应的分别是 await、signal 和 signalAll。
示例：使用显示条件变量的有界缓存
public class ConditionBoundedBuffer<T> {
private final T[] buffer;
private int tail, head, count;
private final Lock lock = new ReentrantLock();
private final Condition notFull = lock.newCondition();
private final Condition notEmpty = lock.newCondition();
public ConditionBoundedBuffer(int size) {
this.buffer = (T[]) new Object[size];
}
public void put(T e) throws InterruptedException {
try {
lock.lock();
while (isFull())
notFull.await();
putInternal(e);
notEmpty.signal();
} finally {
lock.unlock();
}
}
public T take() throws InterruptedException {
try {
lock.lock();
while (isEmpty())
notEmpty.await();
T result = takeInternal();
notFull.signal();
return result;
} finally {
lock.unlock();
}
}
private void putInternal(T e) {
buffer[tail] = e;
count++;
tail = (tail + 1) % buffer.length;
}
private T takeInternal() {
T result = buffer[head];
buffer[head] = null;
count--;
head = (head + 1) % buffer.length;
return result;
}
private boolean isFull() {
return count >= buffer.length;
}
private boolean isEmpty() {
return count <= 0;
}
}