feat: add BlockingQueueWorkingThreadSafe demonstrating producer-consumer pattern and thread-safe queues

Implemented BlockingQueueWorkingThreadSafe.java to showcase how BlockingQueue ensures
safe communication between producer and consumer threads using put() and take().
Includes examples of ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueue,
and SynchronousQueue with concurrency characteristics and blocking behavior explained.

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

Author: Someshdiwan

Section 25 Collections Frameworks/Queue Interface/Blocking Queue/src/BlockingQueueWorkingThreadSafe.java

@@ -50,31 +50,34 @@ public class BlockingQueueWorkingThreadSafe {
     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 an array.
+        // 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();
 
         BlockingQueue<Integer> queue1 =  new LinkedBlockingQueue<>();
-        // optionally bounded backed by LinkedList
+        // optionally boundedly backed by LinkedList
         // Uses two separate locks for enqueue and dequeue operations
         // Higher concurrency between producers and consumers
 
         BlockingQueue<String> queue2 = new PriorityBlockingQueue<>(11, Comparator.reverseOrder());
-
-        // unbounded
-        // Binary Heap as array and can grow dynamically
+        // Unbounded
+        // Binary Heap as an array and can grow dynamically
         // Head is based on their natural ordering or a provided Comparator like priority queue
         // put won't block
         queue2.add("apple");
         queue2.add("banana");
         queue2.add("cherry");
         System.out.println(queue2);
+
         BlockingQueue<Integer> queue3 =  new SynchronousQueue<>();
         // each insert operation must wait for a corresponding remove operation by another thread and vice versa.
         // it cannot store elements, capacity of at most one element
+
     }
 }
 
@@ -93,6 +96,4 @@ public static void main(String[] args) {
 
 A bounded, blocking queue backed by a circular array low memory overhead uses a single lock
 for both enqueue and dequeue operations
-
-more threads --> problem
 */