设计有限阻塞队列

/*
题目思路：
1. 设计一个有限阻塞队列，使用Java Stream的特性来处理元素。
2. 使用队列的数据结构，并实现流式API的处理方法。
3. 实现以下方法：
   - BoundedBlockingQueue(int capacity): 构造函数，初始化队列的容量。
   - void enqueue(int element): 将元素添加到队列末尾，如果队列已满则等待。
   - int dequeue(): 从队列头部删除并返回元素，如果队列为空则等待。
   - int size(): 返回队列中当前元素的数量。
*/

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.stream.IntStream;

public class BoundedBlockingQueueStream {
    private int capacity;
    private Queue<Integer> queue;
    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();

    public BoundedBlockingQueueStream(int capacity) {
        this.capacity = capacity;
        this.queue = new LinkedList<>();
    }

    public void enqueue(int element) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == capacity) {
                notFull.await();
            }
            queue.offer(element);
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public int dequeue() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                notEmpty.await();
            }
            int result = queue.poll();
            notFull.signal();
            return result;
        } finally {
            lock.unlock();
        }
    }

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

    public IntStream stream() {
        lock.lock();
        try {
            return queue.stream().mapToInt(Integer::intValue);
        } finally {
            lock.unlock();
        }
    }
}