feat(datastructures): add thread-safe bounded queue implementation (#7428)

* feat(datastructures): add thread-safe bounded queue implementation

Implements a thread-safe blocking queue using ReentrantLock and
Condition variables for producer-consumer synchronization.

### What This Adds

**ThreadSafeQueue.java** - Thread-safe bounded queue:
- `enqueue()` - Blocking add to tail, waits when queue is full
- `dequeue()` - Blocking remove from head, waits when queue is empty
- `offer()` - Non-blocking add, returns false when full
- `poll()` - Non-blocking remove, returns null when empty
- `size()`, `isEmpty()`, `isFull()`, `capacity()` - State queries
- Uses circular buffer for O(1) enqueue/dequeue operations
- Supports multiple concurrent producers and consumers

**ThreadSafeQueueTest.java** - Comprehensive test suite:
- Basic enqueue/dequeue operations
- Offer/poll non-blocking behavior
- Null rejection validation
- Invalid capacity rejection
- Circular buffer wrap-around
- Multiple producers single consumer concurrency
- Single producer multiple consumers concurrency
- Blocking behavior verification
- Stress test with 8 concurrent threads

### Algorithm

Uses a circular buffer with ReentrantLock and two Condition variables:
- `notFull` - signaled when space becomes available
- `notEmpty` - signaled when items are added
- Producers await notFull when buffer is full
- Consumers await notEmpty when buffer is empty
- Signal opposite condition after each operation

Time: O(1) enqueue/dequeue | Space: O(n) bounded buffer

### Reference

https://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem

* fix(datastructures): correct test capacity and simplify concurrent test

- testOfferPoll: Changed capacity from 3 to 2 so third offer correctly fails
- testMultipleProducersSingleConsumer: Removed startLatch, use dedicated
  consumer thread with synchronized results list for thread safety

* fix(datastructures): remove unused assertArrayEquals import

Checkstyle flagged UnusedImports violation for
org.junit.jupiter.api.Assertions.assertArrayEquals which was
not used in any test method.

* fix: replace signal() with signalAll() to satisfy SpotBugs MDM_SIGNAL_NOT_SIGNALALL

SpotBugs flags all four Condition.signal() calls in ThreadSafeQueue as Medium
severity bugs (MDM_SIGNAL_NOT_SIGNALALL). In a multi-producer/multi-consumer
scenario, signal() wakes only one waiting thread, which can cause deadlock when
multiple producers or consumers are blocked on the same condition variable.
Using signalAll() ensures all waiting threads are notified and can re-check
their loop condition, preventing the lost-wakeup problem that occurs when a
single signal wakes a thread that cannot make progress.

This change affects enqueue(), dequeue(), offer(), and poll() methods where
notEmpty.signal() and notFull.signal() are replaced with notEmpty.signalAll()
and notFull.signalAll() respectively.

* test: replace static imports with Assertions prefix to satisfy PMD TooManyStaticImports

PMD flags TooManyStaticImports when more than 4 static imports are present.
The test file had 5 static imports from org.junit.jupiter.api.Assertions
(equals, assertFalse, assertNull, assertThrows, assertTrue) which exceeded
the default threshold. Replaced with regular import and Assertions.
prefix to eliminate the PMD violation while maintaining readability.

Author: MD-Mushfiqur123

src/main/java/com/thealgorithms/datastructures/queues/ThreadSafeQueue.java

@@ -0,0 +1,186 @@
+package com.thealgorithms.datastructures.queues;
+
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * @brief Thread-safe bounded queue implementation using ReentrantLock and Condition variables
+ * @details A blocking queue that supports multiple producers and consumers.
+ * Uses a circular buffer internally with lock-based synchronization to ensure
+ * thread safety. Producers block when the queue is full, and consumers block
+ * when the queue is empty.
+ * @see <a href="https://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem">Producer-Consumer Problem</a>
+ */
+public class ThreadSafeQueue<T> {
+
+    private final Object[] buffer;
+    private final int capacity;
+    private int head;
+    private int tail;
+    private int count;
+    private final ReentrantLock lock;
+    private final Condition notFull;
+    private final Condition notEmpty;
+
+    /**
+     * @brief Constructs a ThreadSafeQueue with the specified capacity
+     * @param capacity the maximum number of elements the queue can hold
+     * @throws IllegalArgumentException if capacity is less than or equal to zero
+     */
+    public ThreadSafeQueue(int capacity) {
+        if (capacity <= 0) {
+            throw new IllegalArgumentException("Capacity must be greater than zero.");
+        }
+        this.capacity = capacity;
+        this.buffer = new Object[capacity];
+        this.head = 0;
+        this.tail = 0;
+        this.count = 0;
+        this.lock = new ReentrantLock();
+        this.notFull = lock.newCondition();
+        this.notEmpty = lock.newCondition();
+    }
+
+    /**
+     * @brief Adds an element to the tail of the queue, blocking if full
+     * @param item the element to add
+     * @throws InterruptedException if the thread is interrupted while waiting
+     * @throws IllegalArgumentException if the item is null
+     */
+    public void enqueue(T item) throws InterruptedException {
+        if (item == null) {
+            throw new IllegalArgumentException("Cannot enqueue null item.");
+        }
+
+        lock.lock();
+        try {
+            while (count == capacity) {
+                notFull.await();
+            }
+            buffer[tail] = item;
+            tail = (tail + 1) % capacity;
+            count++;
+            notEmpty.signalAll();
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /**
+     * @brief Removes and returns the element at the head of the queue, blocking if empty
+     * @return the element at the head of the queue
+     * @throws InterruptedException if the thread is interrupted while waiting
+     */
+    @SuppressWarnings("unchecked")
+    public T dequeue() throws InterruptedException {
+        lock.lock();
+        try {
+            while (count == 0) {
+                notEmpty.await();
+            }
+            T item = (T) buffer[head];
+            buffer[head] = null;
+            head = (head + 1) % capacity;
+            count--;
+            notFull.signalAll();
+            return item;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /**
+     * @brief Adds an element to the tail of the queue without blocking
+     * @param item the element to add
+     * @return true if the element was added, false if the queue was full
+     * @throws IllegalArgumentException if the item is null
+     */
+    public boolean offer(T item) {
+        if (item == null) {
+            throw new IllegalArgumentException("Cannot enqueue null item.");
+        }
+
+        lock.lock();
+        try {
+            if (count == capacity) {
+                return false;
+            }
+            buffer[tail] = item;
+            tail = (tail + 1) % capacity;
+            count++;
+            notEmpty.signalAll();
+            return true;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /**
+     * @brief Removes and returns the element at the head without blocking
+     * @return the element at the head, or null if the queue is empty
+     */
+    @SuppressWarnings("unchecked")
+    public T poll() {
+        lock.lock();
+        try {
+            if (count == 0) {
+                return null;
+            }
+            T item = (T) buffer[head];
+            buffer[head] = null;
+            head = (head + 1) % capacity;
+            count--;
+            notFull.signalAll();
+            return item;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /**
+     * @brief Returns the number of elements in the queue
+     * @return the current size of the queue
+     */
+    public int size() {
+        lock.lock();
+        try {
+            return count;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /**
+     * @brief Checks if the queue is empty
+     * @return true if the queue contains no elements
+     */
+    public boolean isEmpty() {
+        lock.lock();
+        try {
+            return count == 0;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /**
+     * @brief Checks if the queue is full
+     * @return true if the queue has reached its capacity
+     */
+    public boolean isFull() {
+        lock.lock();
+        try {
+            return count == capacity;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /**
+     * @brief Returns the maximum capacity of the queue
+     * @return the capacity
+     */
+    public int capacity() {
+        return capacity;
+    }
+}