[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":82,"_72":83,"_35":84},"articles",{"_11":12,"_13":14,"_15":16,"_17":16,"_18":19,"_20":21,"_22":23,"_24":23,"_25":16,"_26":27},"content",[30],"pageable",{"_28":21,"_29":19},"totalElements",1,"totalPages","size",10,"number",0,"first",true,"last","numberOfElements","empty",false,"page_number","page_size",{"_31":32,"_33":34,"_35":36,"_37":38,"_11":39,"_40":-5,"_41":23,"_42":27,"_43":44,"_45":46,"_47":48,"_49":50,"_51":52,"_53":52,"_54":55,"_56":57,"_58":59,"_60":52,"_61":52,"_62":63,"_64":65,"_66":67,"_68":69,"_70":71},"id",86,"title","BlockingQueue","slug","dsa-cheatsheet-part-15-blockingqueue","excerpt","Visual guide to BlockingQueue: producer-consumer pattern. Watch threads block and unblock on queue operations.","# BlockingQueue\n\n## 📋 Quick Reference\n\n| Property | Value |\n|----------|-------|\n| **Type** | Thread-safe queue with blocking operations |\n| **Key Feature** | Threads block until operation can proceed |\n| **Common Impls** | ArrayBlockingQueue, LinkedBlockingQueue |\n| **Thread Safety** | Fully thread-safe |\n| **Null** | Not allowed |\n| **Best For** | Producer-consumer pattern, thread pools |\n\n**One-liner**: *Thread-safe queue where threads block on empty/full instead of failing.*\n\n---\n\n## 🎮 Interactive Visualizer\n\nWatch producers and consumers interact through a blocking queue:\n\n```visualizer-blockingqueue\nshowControls: true\nshowCode: true\n```\n\n**Try these operations:**\n1. Add producers faster than consumers - see queue fill up\n2. Watch producer block when queue is full\n3. See consumer block when queue is empty\n4. Observe the handoff between threads\n\n---\n\n## 🔧 Key Operations\n\n### Creating\n\n```java\n// Bounded (fixed capacity)\nBlockingQueue queue = new ArrayBlockingQueue<>(100);\n\n// Bounded linked\nBlockingQueue queue = new LinkedBlockingQueue<>(100);\n\n// Unbounded (Integer.MAX_VALUE capacity)\nBlockingQueue queue = new LinkedBlockingQueue<>();\n\n// Priority-based\nBlockingQueue queue = new PriorityBlockingQueue<>();\n\n// Delay-based\nBlockingQueue queue = new DelayQueue<>();\n\n// Synchronous handoff (capacity 0)\nBlockingQueue queue = new SynchronousQueue<>();\n```\n\n### Blocking Operations (Wait Forever)\n\n```java\n// Blocks until space available\nqueue.put(item);\n\n// Blocks until element available\nItem item = queue.take();\n```\n\n### Timed Blocking Operations\n\n```java\n// Blocks up to timeout, returns false if timeout\nboolean added = queue.offer(item, 5, TimeUnit.SECONDS);\n\n// Blocks up to timeout, returns null if timeout\nItem item = queue.poll(5, TimeUnit.SECONDS);\n```\n\n### Non-Blocking Operations\n\n```java\n// Returns false if full (doesn't block)\nboolean added = queue.offer(item);\n\n// Returns null if empty (doesn't block)\nItem item = queue.poll();\n\n// Throws exception if full\nqueue.add(item); // throws IllegalStateException\n\n// Throws exception if empty\nItem item = queue.remove(); // throws NoSuchElementException\nItem item = queue.element(); // throws NoSuchElementException\n\n// Returns null if empty (peek, doesn't remove)\nItem item = queue.peek();\n```\n\n### Bulk Operations\n\n```java\n// Drain up to maxElements to collection\nint count = queue.drainTo(collection, 100);\n\n// Drain all\nint count = queue.drainTo(collection);\n\n// Remaining capacity\nint space = queue.remainingCapacity();\n```\n\n---\n\n## 📊 Operation Behavior Summary\n\n| Method | Full Queue | Empty Queue |\n|--------|------------|-------------|\n| `put()` | Blocks | N/A |\n| `offer()` | Returns false | N/A |\n| `offer(timeout)` | Blocks then false | N/A |\n| `add()` | Throws exception | N/A |\n| `take()` | N/A | Blocks |\n| `poll()` | N/A | Returns null |\n| `poll(timeout)` | N/A | Blocks then null |\n| `remove()` | N/A | Throws exception |\n\n---\n\n## ✅ When to Use BlockingQueue\n\n### Good Use Cases\n\n- **Producer-consumer** - decouple production from consumption\n- **Thread pools** - task queue for worker threads\n- **Backpressure** - bounded queue limits producer speed\n- **Pipeline stages** - connect processing stages\n- **Event handling** - async event processing\n\n### Choose Implementation By Need\n\n| Implementation | Use When |\n|---------------|----------|\n| `ArrayBlockingQueue` | Fixed capacity, fairness needed |\n| `LinkedBlockingQueue` | High throughput, flexible capacity |\n| `PriorityBlockingQueue` | Priority-based processing |\n| `DelayQueue` | Delayed/scheduled tasks |\n| `SynchronousQueue` | Direct handoff, no buffering |\n\n---\n\n## 🧩 Common Patterns\n\n### Basic Producer-Consumer\n\n```java\nBlockingQueue queue = new ArrayBlockingQueue<>(100);\n\n// Producer\nRunnable producer = () -> {\n while (true) {\n Task task = createTask();\n try {\n queue.put(task); // Blocks if full\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n break;\n }\n }\n};\n\n// Consumer\nRunnable consumer = () -> {\n while (true) {\n try {\n Task task = queue.take(); // Blocks if empty\n process(task);\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n break;\n }\n }\n};\n\n// Start threads\nnew Thread(producer).start();\nnew Thread(consumer).start();\n```\n\n### Multiple Consumers (Work Stealing)\n\n```java\nBlockingQueue queue = new LinkedBlockingQueue<>(1000);\n\n// Start multiple consumers\nint numConsumers = Runtime.getRuntime().availableProcessors();\nExecutorService consumers = Executors.newFixedThreadPool(numConsumers);\n\nfor (int i = 0; i < numConsumers; i++) {\n consumers.submit(() -> {\n while (!Thread.currentThread().isInterrupted()) {\n try {\n Task task = queue.take();\n process(task);\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n }\n });\n}\n```\n\n### Graceful Shutdown with Poison Pill\n\n```java\nTask POISON_PILL = new Task(\"STOP\");\n\n// Producer sends poison pill when done\nqueue.put(POISON_PILL);\n\n// Consumer checks for poison pill\nwhile (true) {\n Task task = queue.take();\n if (task == POISON_PILL) {\n queue.put(POISON_PILL); // Pass to next consumer\n break;\n }\n process(task);\n}\n```\n\n### Timeout-Based Consumer\n\n```java\nwhile (running) {\n Task task = queue.poll(1, TimeUnit.SECONDS);\n if (task != null) {\n process(task);\n } else {\n // Timeout - check if should continue\n if (shouldShutdown()) break;\n }\n}\n```\n\n---\n\n## ⚠️ Common Pitfalls\n\n### 1. Ignoring InterruptedException\n\n```java\n// ❌ Swallowing interrupt\ntry {\n queue.take();\n} catch (InterruptedException e) {\n // Don't ignore!\n}\n\n// ✅ Restore interrupt status\ntry {\n queue.take();\n} catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n throw new RuntimeException(e);\n}\n```\n\n### 2. Using Unbounded Queue with Fast Producer\n\n```java\n// ❌ Can cause OutOfMemoryError\nBlockingQueue queue = new LinkedBlockingQueue<>(); // Unbounded!\n// Fast producer fills memory\n\n// ✅ Use bounded queue for backpressure\nBlockingQueue queue = new LinkedBlockingQueue<>(1000);\n```\n\n### 3. Blocking in Main Thread\n\n```java\n// ❌ Blocks main/UI thread\nTask task = queue.take(); // UI freezes!\n\n// ✅ Block only in worker threads\nexecutor.submit(() -> {\n Task task = queue.take();\n // ...\n});\n```\n\n### 4. Wrong Method for Use Case\n\n```java\n// ❌ add() throws exception on full queue\ntry {\n queue.add(item); // Throws if full\n} catch (IllegalStateException e) {\n // Handle failure\n}\n\n// ✅ Use put() to block, offer() to fail gracefully\nqueue.put(item); // Blocks until space\n// or\nif (!queue.offer(item)) {\n handleQueueFull();\n}\n```\n\n---\n\n## 🎤 Interview Tips\n\n**Q: What's the difference between put() and offer()?**\n\n> put() blocks until space is available - use for producer-consumer where blocking is desired. offer() returns false immediately if full - use when you need non-blocking behavior or want to handle backpressure differently.\n\n**Q: Why use BlockingQueue instead of synchronized + wait/notify?**\n\n> BlockingQueue encapsulates the synchronization logic, handles edge cases correctly, and provides a cleaner API. It's less error-prone than manual wait/notify and better tested.\n\n**Q: ArrayBlockingQueue vs LinkedBlockingQueue?**\n\n> Array is fixed-size with better memory locality. Linked can grow (if unbounded) and may have higher throughput in high-contention scenarios due to separate head/tail locks.\n\n**Q: What's SynchronousQueue?**\n\n> A queue with zero capacity - put() blocks until another thread calls take(). Used for direct handoff between threads, like in cached thread pools where tasks are handed directly to waiting threads.\n\n---\n\n## 📚 Series Navigation\n\n**Previous**: [Part 14: ConcurrentHashMap](dsa-cheatsheet-part-14-concurrenthashmap)\n\n**Next**: [Part 16: Copy-on-Write Collections](dsa-cheatsheet-part-16-copyonwrite)\n\n---\n\n**Visualizer**: `BlockingQueue` from `@tomaszjarosz/react-visualizers`\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:25.727645Z","createdAt","2026-06-10T07:19:25.727907Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",4,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Algorithms","readingTime","seriesId","seriesOrder",15,"author",{"_31":55,"_98":57,"_99":100,"_101":102,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5},"category",{"_31":94,"_72":59,"_35":95,"_75":96,"_97":-5},"tags",[78,79,80,81],"series",{"_31":52,"_72":73,"_35":74,"_75":76,"_77":23},"name","Interactive Data Structures & Algorithms","dsa-visualized-cheatsheet","description","A concise, visual reference for essential data structures and algorithms. Each article features an interactive visualizer showing how the structure/algorithm works step-by-step, along with complexity analysis, use cases, and quick reference code. Perfect for interview prep, quick review, or learning by visualization.","isActive",{"_31":91,"_72":92,"_35":93},{"_31":88,"_72":89,"_35":90},{"_31":85,"_72":86,"_35":87},{"_31":82,"_72":83,"_35":84},288,"Thread","thread",287,"Producer-consumer","producer-consumer",283,"Concurrency","concurrency",286,"Blockingqueue","blockingqueue",6,"algorithms","Category for Algorithms","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]