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

Important Methods

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

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

Real-World Use Cases

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