Thread-Safe Bounded Producer-Consumer Queue

Problem Context

In concurrent programming, the Producer-Consumer pattern is a classic synchronization problem where one or more producer threads generate data and place it into a shared buffer, while one or more consumer threads retrieve and process that data.

Your task is to implement a bounded, thread-safe queue in Java that supports concurrent producers and consumers. The queue must handle blocking behavior when it is full (producers wait) or empty (consumers wait).

Requirements

Implement a class BoundedQueue<T> with the following API:

class BoundedQueue<T> {
    public BoundedQueue(int capacity) { ... }
    public void put(T item) throws InterruptedException { ... } // blocks if full
    public T take() throws InterruptedException { ... }         // blocks if empty
    public int size() { ... }                                  // current number of elements
    public boolean isEmpty() { ... }                           // true if no elements
    public boolean isFull() { ... }                            // true if at max capacity
}

Behavior

• put(item): Adds an item to the queue. If the queue is full, the calling thread blocks until space becomes available.
• take(): Removes and returns the front item. If the queue is empty, the calling thread blocks until an item is available.
• All methods must be thread-safe and free of data races.
• The queue must behave as a FIFO (First-In, First-Out) structure.