请用ReentrantLock和Condition实现一个简单的阻塞队列

好的，我可以为你实现一个基于ReentrantLock和Condition的简单阻塞队列。

首先，我们需要定义一个队列类，包含以下方法：

- `enqueue(item)`：将元素放入队列中。
- `dequeue()`：从队列中取出元素。
- `size()`：返回队列的大小。

下面是使用ReentrantLock和Condition实现的代码：

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

public class BlockingQueue<T> {
    private Queue<T> queue;
    private int maxSize;
    private ReentrantLock lock;
    private Condition notEmpty;
    private Condition notFull;

    public BlockingQueue(int maxSize) {
        this.maxSize = maxSize;
        this.queue = new LinkedList<>();
        this.lock = new ReentrantLock();
        this.notEmpty = lock.newCondition();
        this.notFull = lock.newCondition();
    }

    public void enqueue(T item) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == maxSize) { // 队列已满，等待直到队列不满
                notFull.await();
            }
            queue.add(item);
            notEmpty.signalAll(); // 通知等待中的线程队列不为空
        } finally {
            lock.unlock();
        }
    }

    public T dequeue() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) { // 队列为空，等待直到队列不为空
                notEmpty.await();
            }
            T item = queue.remove();
            notFull.signalAll(); // 通知等待中的线程队列不满
            return item;
        } finally {
            lock.unlock();
        }
    }

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

使用这个阻塞队列的示例代码如下：

public class Main {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new BlockingQueue<>(5);

        Thread producer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    queue.enqueue(i);
                    System.out.println("Produced: " + i);
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread consumer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    int item = queue.dequeue();
                    System.out.println("Consumed: " + item);
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        producer.start();
        consumer.start();
    }
}

在这个示例中，生产者线程不断地将元素放入队列中，消费者线程不断地从队列中取出元素。当队列已满时，生产者线程会被阻塞，直到有空余位置；当队列为空时，消费者线程会被阻塞，直到有元素可取。

希望这个简单的阻塞队列的实现对你有帮助！如果还有其他问题，请继续提问。