Types of BlockingQueue in Java

Java offers seven key BlockingQueue implementations in the java.util.concurrent package.
Each implementation is designed for specific concurrency scenarios, such as buffering, producer–consumer coordination, direct handoff, delayed execution, or priority-based processing.

1. ArrayBlockingQueue

ArrayBlockingQueue is a fixed-size blocking queue backed by an array.

• If the queue is full, producers wait.
• If the queue is empty, consumers wait.

Type: Bounded (fixed size)

Internal Structure: Array

Thread Safety: Yes (locks)

Features

• Must specify capacity
• Optional fairness policy (FIFO fairness)
• Predictable memory usage
• Slightly faster for small queues

Best Use Case

Use it when queue size is known and memory should remain fixed.

---

2. LinkedBlockingQueue

LinkedBlockingQueue can be used as:

• Bounded queue (recommended)
• Unbounded queue (default almost unlimited)

Type: Bounded or Unbounded

Internal Structure: Linked Nodes

Features

• Larger capacity
• Higher throughput
• Uses separate locks for put and take → less contention

Best Use Case

Use it for high-throughput producer-consumer systems.

---

3. PriorityBlockingQueue

PriorityBlockingQueue removes elements based on priority, not order of insertion.

Type: Unbounded

Internal Structure: Priority Heap (min-heap)

Ordering: Natural order OR custom Comparator

Features

• Always removes the smallest element first
• Unbounded → grows automatically
• Elements must be Comparable or require a Comparator

Best Use Case

Use it when tasks must execute based on priority.

---

4. DelayQueue

DelayQueue holds elements that become available after a specific delay expires.

Type: Unbounded

Special Feature: Delayed element availability

Requirement: Elements must implement Delayed interface

Features

• Excellent for scheduling
• Ideal for caching with expiration
• Internally uses PriorityQueue for delay order

Best Use Case

Use it for delayed tasks, retry systems, scheduled jobs.

---

5. SynchronousQueue

SynchronousQueue does not store elements.

Each put() waits for a corresponding take().

Type: No Capacity (size = 0)

Special Behavior: Direct handoff

Features

• Producer and consumer meet immediately
• Used in cached thread pools
• Extremely fast task handoff

Best Use Case

Use it when one thread hands tasks directly to another (no buffering).

---

6. LinkedTransferQueue

LinkedTransferQueue is an advanced, non-blocking, highly optimized queue.

It supports:

• transfer(e): instantly hands off element if consumer exists
• Otherwise, producer waits

Type: Unbounded

Special Feature: transfer() method

Internal Structure: Linked nodes (high-performance)

Features

• Faster than LinkedBlockingQueue
• Ideal for heavy producer-consumer workloads
• High throughput

Best Use Case

Use it for high-performance message passing between threads.

---

7. LinkedBlockingDeque (BlockingDeque)

LinkedBlockingDeque is a double-ended blocking queue (Deque + BlockingQueue).

You can insert/remove from both ends:

• putFirst(), putLast()
• takeFirst(), takeLast()

Type: Bounded / Unbounded

Internal Structure: Linked Nodes

Category: Double-ended BlockingQueue

Features

• Supports FIFO + LIFO
• Larger and flexible
• Useful for work-stealing patterns

Best Use Case

Use it when you need both queue and stack operations in a thread-safe manner.

---

Summary Table for Quick Revision