• await()：线程等待直到被通知或者中断。类似于 Object.wait()。
• awaitUninterruptibly()：线程等待直到被通知，即使在等待时被中断也不会返回。没有与之对应的 Object 方法。
• await(long time, TimeUnit unit)：线程等待指定的时间，或被通知，或被中断。类似于 Object.wait(long timeout)，但提供了更灵活的时间单位。
• awaitNanos(long nanosTimeout)：线程等待指定的纳秒时间，或被通知，或被中断。没有与之对应的 Object 方法。
• awaitUntil(Date deadline)：线程等待直到指定的截止日期，或被通知，或被中断。没有与之对应的 Object 方法。
• signal()：唤醒一个等待的线程。类似于 Object.notify()。
• signalAll()：唤醒所有等待的线程。类似于 Object.notifyAll()。

• wait()：线程等待直到被通知或者中断。
• wait(long timeout)：线程等待指定的时间，或被通知，或被中断。
• wait(long timeout, int nanos)：线程等待指定的时间，或被通知，或被中断。
• notify()：唤醒一个等待的线程。
• notifyAll()：唤醒所有等待的线程。

public class ReentrantLock implements Lock, java.io.Serializable {
    abstract static class Sync extends AbstractQueuedSynchronizer {
        final ConditionObject newCondition() {
            return new ConditionObject();
        }
    }
    public Condition newCondition() {
        return sync.newCondition();
    }
}

public class ConditionObject implements Condition, java.io.Serializable {
    private static final long serialVersionUID = 1173984872572414699L;
    /** First node of condition queue. */
    private transient Node firstWaiter;
    /** Last node of condition queue. */
    private transient Node lastWaiter;
}

public class BoundedBuffer<T> {
    private final LinkedList<T> buffer;  // 使用 LinkedList 作为缓冲区
    private final int capacity;          // 缓冲区最大容量
    private final ReentrantLock lock;    // 互斥锁
    private final Condition notEmpty;    // 缓冲区非空条件
    private final Condition notFull;     // 缓冲区非满条件

    public BoundedBuffer(int capacity) {
        this.capacity = capacity;
        this.buffer = new LinkedList<>();
        this.lock = new ReentrantLock();
        this.notEmpty = lock.newCondition();
        this.notFull = lock.newCondition();
    }

    // 放入一个元素
    public void put(T item) throws InterruptedException {
        lock.lock();
        try {
            // 如果缓冲区满，等待
            while (buffer.size() == capacity) {
                notFull.await();
            }
            buffer.add(item);
            // 通知可能正在等待的消费者
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    // 取出一个元素
    public T take() throws InterruptedException {
        lock.lock();
        try {
            // 如果缓冲区空，等待
            while (buffer.isEmpty()) {
                notEmpty.await();
            }
            T item = buffer.removeFirst();
            // 通知可能正在等待的生产者
            notFull.signal();
            return item;
        } finally {
            lock.unlock();
        }
    }
}