feat: add ArrayBlockingQueueWorkingThreadSafe demonstrating bounded thread-safe queue with producer-consumer

Implemented ArrayBlockingQueueWorkingThreadSafe.java to illustrate how
ArrayBlockingQueue manages producer-consumer synchronization using a single lock.
Demonstrates blocking behavior of put() and take() methods on a fixed-capacity
circular array, emphasizing bounded concurrency and thread-safe communication.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section 25 Collections Frameworks/Queue Interface/Array Blocking Queue/src/Pending.java

@@ -0,0 +1,61 @@
+import java.util.concurrent.*;
+
+class Producer implements Runnable {
+    private BlockingQueue<Integer> queue;
+    private int value = 0;
+
+    public Producer(BlockingQueue<Integer> queue) {
+        this.queue = queue;
+    }
+
+    @Override
+    public void run() {
+        while (true) {
+            try {
+                System.out.println("Producer produced: " + value);
+                queue.put(value++);
+                Thread.sleep(1000);
+            } catch (Exception e) {
+                Thread.currentThread().interrupt();
+                System.out.println("Producer interrupted");
+            }
+        }
+    }
+}
+
+class Consumer implements Runnable {
+    private BlockingQueue<Integer> queue;
+
+    public Consumer(BlockingQueue<Integer> queue) {
+        this.queue = queue;
+    }
+
+    @Override
+    public void run() {
+        while (true) {
+            try {
+                Integer value = queue.take();
+                System.out.println("Consumer consumed: " + value);
+                Thread.sleep(2000);
+            } catch (Exception e) {
+                Thread.currentThread().interrupt();
+                System.out.println("Consumer interrupted");
+            }
+        }
+    }
+}
+
+public class ArrayBlockingQueueWorkingThreadSafe {
+    public static void main(String[] args) {
+        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);
+        // BlockingQueue is interfaced so we cannot instantiate, so we wrote here implementation of ArrayBlockingQueue
+        // A bounded, blocking Queue backed by a circular array.
+
+        // uses a single lock for both enqueue and dequeue operations
+        // more threads --> problem
+        Thread producer = new Thread(new Producer(queue));
+        Thread consumer = new Thread(new Consumer(queue));
+        producer.start();
+        consumer.start();
+    }
+}