feat: add UnboundedQueueDemo illustrating producer-consumer model with LinkedBlockingQueue

Implemented UnboundedQueueDemo.java to demonstrate unbounded blocking queue behavior
using LinkedBlockingQueue. Showcases asynchronous coordination between producer and
consumer threads where put() and take() handle synchronization automatically without
capacity limits.

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

Author: Someshdiwan

Section 25 Collections Frameworks/Queue Interface/Bounded Queues And Unbounded Queue/src/Unbounded Queue.txt

@@ -0,0 +1,73 @@
+An unbounded queue has no fixed capacity limit — it can grow dynamically
+until available system memory is exhausted.
+
+Producers adding elements never block, as the queue always accepts new items.
+
+In Java:
+- `LinkedBlockingQueue` → optionally bounded, but unbounded by default (capacity = Integer.MAX_VALUE).
+- `PriorityBlockingQueue` → always unbounded, ordered by priority or natural order.
+- `DelayQueue` → always unbounded, elements become available only after their delay expires.
+
+This design is useful when the number of elements is unpredictable and memory
+resources are sufficient.
+
+Unbounded Queue (e.g., `LinkedBlockingQueue`, `DelayQueue`)
+
+          ┌────────────────────────────────────────────┐
+          │             Unbounded BlockingQueue        │
+          │────────────────────────────────────────────│
+Producer →│ [Task1] → [Task2] → [Task3] → [Task4] → …  │→ Consumer
+          │────────────────────────────────────────────│
+          │  • No fixed capacity limit                 │
+          │  • Grows dynamically (until memory limit)  │
+          │  • put() never blocks                      │
+          │  • take() blocks if queue is empty         │
+          └────────────────────────────────────────────┘
+
+
+Producer threads:
+┌───────────┐     ┌───────────┐     ┌───────────┐
+│ Producer1 │ →→→ │ Producer2 │ →→→ │ Producer3 │
+└───────────┘     └───────────┘     └───────────┘
+        │                │                │
+        ▼                ▼                ▼
+┌──────────────────────────────────────────────────┐
+│ Queue: [Task1][Task2][Task3][Task4][Task5]…∞     │
+└──────────────────────────────────────────────────┘
+        │
+        ▼
+        🚀 Keeps accepting new tasks (until memory full)
+
+Consumer thread:
+┌───────────┐
+│ Consumer1 │ → takes → processes → repeats
+└───────────┘
+
+
+Summary of Behavior
+
+| Queue Type               | Capacity Type | put() when Full  | take() when Empty| Example Use Case                    |
+|--------------------------|---------------|------------------|------------------|-------------------------------------|
+| `LinkedBlockingQueue`    | Unbounded     | Never blocks     | Blocks           | Generic producer-consumer model     |
+| `PriorityBlockingQueue`  | Unbounded     | Never blocks     | Blocks           | Priority-based task scheduling      |
+| `DelayQueue`             | Unbounded     | Never blocks     | Blocks (until delay expires) | Delayed job execution   |
+
+In short:
+An unbounded queue favors flexibility and throughput by eliminating
+capacity restrictions.
+
+It is ideal for applications where queue size is expected to remain reasonable,
+but it can be risky if producers outpace consumers — potentially causing
+OutOfMemoryError due to uncontrolled growth.
+
+
+          ┌────────────────────────────────────────────┐
+          │             Unbounded BlockingQueue        │
+          │────────────────────────────────────────────│
+Producer →│  [Task1] → [Task2] → [Task3] → [Task4] → … │→ Consumer
+          │────────────────────────────────────────────│
+          │  • No fixed capacity limit                 │
+          │  • Grows dynamically (until memory limit)  │
+          │  • put() never blocks                      │
+          │  • take() blocks if queue is empty         │
+          └────────────────────────────────────────────┘

Section 25 Collections Frameworks/Queue Interface/Bounded Queues And Unbounded Queue/src/UnboundedQueueDemo.java

@@ -0,0 +1,33 @@
+import java.util.concurrent.*;
+
+public class UnboundedQueueDemo {
+    public static void main(String[] args) throws InterruptedException {
+        BlockingQueue<String> queue = new LinkedBlockingQueue<>(); // unbounded by default
+
+        // Producer Thread
+        new Thread(() -> {
+            try {
+                for (int i = 1; i <= 5; i++) {
+                    queue.put("Task-" + i);
+                    System.out.println("Produced: Task-" + i);
+                    Thread.sleep(500);
+                }
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+        }).start();
+
+        // Consumer Thread
+        new Thread(() -> {
+            try {
+                while (true) {
+                    String task = queue.take();
+                    System.out.println("Consumed: " + task);
+                    Thread.sleep(1000);
+                }
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+        }).start();
+    }
+}