ReentrantLock 与 Condition

public void accessMutex() {
    Lock lock = new ReentrantLock();
    lock.lock();
    try {
        // access
    } finally {
        lock.unlock();
    }
}

public class ConditionExample {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private boolean businessCondition = false;

    public void waitCondition() throws InterruptedException {
        lock.lock();
        try {
            while (!businessCondition) {
                condition.await();  // 业务条件不满足，线程进入等待状态
            }
        } finally {
            lock.unlock();
        }
    }
    
    public void meetCondition() {
        lock.lock();
        try {
            businessCondition = true;
            condition.signal();  // 唤醒等待条件的线程
        } finally {
            lock.unlock();
        }
    }
}

public class MyBlockingQueueV2<T> {

    private Object[] data;
    private int getIndex;
    private int putIndex;
    private int cnt;

    private final Lock lock;
    private final Condition notFull;
    private final Condition notEmpty;

    public MyBlockingQueueV2(int size) {
        this.data = new Object[size];
        this.lock = new ReentrantLock();
        this.notFull = lock.newCondition();
        this.notEmpty = lock.newCondition();
    }

    public void put(T item) throws InterruptedException {
        lock.lock();
        try {
            while (cnt == data.length) {  // 队列满，等待消费。线程唤醒后需重新检查条件是否满足
                notFull.await();
            }
            data[putIndex] = item;
            putIndex = nextIndex(putIndex);
            cnt++;
            notEmpty.signal();  // 唤醒等待的消费线程
        } finally {
            lock.unlock();
        }
    }

    public T get() throws InterruptedException {
        lock.lock();
        try {
            while (cnt == 0) {  // 队列空，等待生产。线程唤醒后需重新检查条件是否满足
                notEmpty.await();
            }
            Object item = data[getIndex];
            getIndex = nextIndex(getIndex);
            cnt--;
            notFull.signal();  // 唤醒等待的生产线程
            return (T) item;
        } finally {
            lock.unlock();
        }
    }

    private int nextIndex(int curIndex) {
        return (curIndex + 1) % data.length;
    }

}