java基于reentrantlock/condition/queue实现阻塞队列

java
package com.example.demo.blocked_queue;

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 有界阻塞队列，基于 ReentrantLock + Condition，使用 JDK Queue 作为缓冲实现
 */
public class MyBlockedQueue<E> {
    private final Queue<E> queue;
    private final int capacity;

    private final ReentrantLock lock = new ReentrantLock();
    private final Condition notEmpty = lock.newCondition();
    private final Condition notFull = lock.newCondition();

    public MyBlockedQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException("capacity must be > 0");
        this.capacity = capacity;
        this.queue = new LinkedList<>();
    }

    // 将元素放入队列，队列满则等待（可中断）
    public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
        lock.lockInterruptibly();
        try {
            while (queue.size() == capacity) {
                notFull.await();
            }
            queue.add(e);
            // 唤醒等待取元素的线程
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    // 从队列取出元素，队列空则等待（可中断）
    public E take() throws InterruptedException {
        lock.lockInterruptibly();
        try {
            while (queue.isEmpty()) {
                notEmpty.await();
            }
            E e = queue.remove();
            // 唤醒等待放元素的线程
            notFull.signal();
            return e;
        } finally {
            lock.unlock();
        }
    }

    public int size() {
        lock.lock();
        try {
            return queue.size();
        } finally {
            lock.unlock();
        }
    }

    public boolean isEmpty() {
        return size() == 0;
    }

    public boolean isFull() {
        lock.lock();
        try {
            return queue.size() == capacity;
        } finally {
            lock.unlock();
        }
    }

    @Override
    public String toString() {
        lock.lock();
        try {
            return "MyBlockedQueue{" +
                    "queue=" + queue +
                    ", capacity=" + capacity +
                    '}';
        } finally {
            lock.unlock();
        }
    }
}