BlockingQueue in Java

A BlockingQueue is a thread-safe queue in Java that blocks (waits) when:

• The queue is full → producers wait until space becomes available
• The queue is empty → consumers wait until an element becomes available

It is part of java.util.concurrent package.

---

What is BlockingQueue?

A BlockingQueue is a special queue designed for producer–consumer problems.

• Producers add items
• Consumers remove items
• If the queue can’t perform the operation (full/empty), it pauses automatically
• No need for manual synchronization

---

Simple Example

BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);

// Producer
queue.put(10);  // waits if full

// Consumer
int value = queue.take();  // waits if empty

---

Features of BlockingQueue

Feature	Description
Thread-safe	All operations are synchronized internally
Blocking operations	put() waits if full, take() waits if empty
No null values	BlockingQueue does not allow null
Ideal for producer–consumer	Used in multi-threading applications

---

Important Methods

Method	Behavior
put(e)	Inserts element, waits if queue is full
take()	Removes element, waits if empty
offer(e)	Inserts without waiting, returns false if full
offer(e, time, unit)	Waits for limited time
poll()	Removes and returns element, returns null if empty
poll(time, unit)	Waits for limited time
remainingCapacity()	Space left in queue

---

BlockingQueue implementations

BlockingQueue implementations come in two types :

• Bounded BlockingQueue
• Unbounded BlockingQueue

Bounded BlockingQueue

• A bounded queue has a fixed capacity (maximum size).
• It cannot grow beyond the given limit.

Characteristics

• Has a maximum limit (e.g., 10 elements)
• put() blocks when full
• Great for controlling memory usage
• Prevents producers from producing too fast

Example (Bounded)

BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);

Unbounded BlockingQueue

• An unbounded queue has no fixed capacity.
• It can grow until system memory is exhausted.

Characteristics

• No maximum limit
• offer() never fails due to capacity
• put() never blocks because capacity never fills
• Good when producers should never be stopped

But risk:

• If producers produce too fast → memory may fill up

Example (Unbounded)

BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

---

Popular BlockingQueue Implementations

Class	Type	Description
ArrayBlockingQueue	Bounded	Uses array (fixed size)
LinkedBlockingQueue	Bounded/Unbounded	Uses linked nodes
PriorityBlockingQueue	Unbounded	Priority-based
DelayQueue	Unbounded	Elements become available after delay
SynchronousQueue	No capacity	One element handoff (direct exchange)
LinkedTransferQueue	Unbounded	Fast transfer operations

---

Producer–Consumer Example Using BlockingQueue

import java.util.concurrent.*;

public class BlockingQueueExample {

    public static void main(String[] args) {

        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);

        // Producer
        Runnable producer = () -> {
            try {
                for (int i = 1; i <= 10; i++) {
                    System.out.println("Producing: " + i);
                    queue.put(i); // waits if full
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        };

        // Consumer
        Runnable consumer = () -> {
            try {
                while (true) {
                    int item = queue.take(); // waits if empty
                    System.out.println("Consuming: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        };

        new Thread(producer).start();
        new Thread(consumer).start();
    }
}

---

When to Use BlockingQueue?

Use BlockingQueue when your application needs:

• Thread-safe communication between producer & consumer
• Automatic waiting/blocking behavior
• Safe handling of tasks in multi-threaded systems
• Queues used inside Executor Framework

---

Bounded vs Unbounded

Feature	Bounded Queue	Unbounded Queue
Capacity	Fixed	No limit
put()	Blocks when full	Never blocks
Memory	Controlled	Can grow → high memory usage
Use-case	Backpressure control	Unlimited tasks
Examples	ArrayBlockingQueue	LinkedBlockingQueue(), PriorityBlockingQueue

---

Real-World Use Cases

• Producer–Consumer problem
• Thread pools
• Message passing systems
• Job scheduling
• Asynchronous logging