GeezerVison

The World Wide Web, restored to 800 pixels of glory.

GeezerVison is showing www.geeksforgeeks.org — BlockingQueue Interface in Java - GeeksforGeeks

Courses
Tutorials
Interview Prep

BlockingQueue Interface in Java

Last Updated : 25 Apr, 2026

The BlockingQueue interface in Java is a thread-safe queue from the java.util.concurrent package used in concurrent programming. It supports blocking operations, making it ideal for producer-consumer scenarios.

Supports blocking methods like put() and take().
Thread-safe, so no explicit synchronization is required.
Does not allow null elements.

Declaration

public interface BlockingQueue<E> extends Queue<E>

Here, E is the type of elements stored in the queue.

Java

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class GFG{
    
    public static void main(String[] args) throws InterruptedException{
        
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(3);

        // Add elements
        queue.put(1);
        queue.put(2);
        queue.put(3);

        System.out.println("BlockingQueue: " + queue);
    }
}

Output

BlockingQueue: [1, 2, 3]

The Hierarchy of BlockingQueue

It extends the Queue interface and provides implementations like LinkedBlockingQueue and ArrayBlockingQueue.

Classes that Implement BlockingQueue

LinkedBlockingQueue: An optionally bounded blocking queue backed by linked nodes, usually with higher throughput than ArrayBlockingQueue.
ArrayBlockingQueue: A bounded blocking queue backed by an array that stores elements in FIFO order.

Types of BlockingQueue

There are two types of BlockingQueue.

1. Unbounded Queue

Unbounded Queue is a queue that has no fixed capacity limit, allowing elements to be added indefinitely until system memory is exhausted.

BlockingQueue blockingQueue = new LinkedBlockingQueue();

Java

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class GFG {
    public static void main(String[] args) throws InterruptedException {

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

        queue.put(10);
        queue.put(20);
        queue.put(30);

        System.out.println("Unbounded Queue: " + queue);
    }
}

Output

Unbounded Queue: [10, 20, 30]

2. Bounded Queue

Bounded Queue is a queue with a fixed capacity that limits the number of elements it can hold at a time.

BlockingQueue blockingQueue = new LinkedBlockingDeque(5);

Java

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class GFG {
    public static void main(String[] args) throws InterruptedException {

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

        queue.put(1);
        queue.put(2);
        queue.put(3);
        // queue.put(4); // blocks if full

        System.out.println("Bounded Queue: " + queue);
    }
}

Output

Bounded Queue: [1, 2, 3]

Basic Operations on BlockingQueue

1. Adding Elements

Elements can be added using add(), put(), or offer() methods.

Java

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;

public class GFG{
    
    public static void main(String[] args){
        
        BlockingQueue<Integer> bq = new LinkedBlockingDeque<>();
        bq.add(78);
        bq.add(35);
        bq.add(52);
        bq.add(74);

        System.out.println("BlockingQueue: " + bq);
    }
}

Output

BlockingQueue: [78, 35, 52, 74]

2. Accessing Elements

The elements of the LinkedBlockingDeque can be accessed using contains(), element(), peek(), poll().

Java

import java.util.concurrent.*;

public class GFG{
    
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new LinkedBlockingDeque<>();

        queue.add(22);
        queue.add(125);
        queue.add(723);
        queue.add(172);
        queue.add(100);

        System.out.println("Queue: " + queue);

        if (queue.contains(22))
            System.out.println("Queue contains 22");
        
        int head = queue.element();
        System.out.println("Head of queue: " + head);
    }
}

Output

Queue: [22, 125, 723, 172, 100]
Queue contains 22
Head of queue: 22

3. Deleting Elements

Elements can be deleted from a LinkedBlockingDeque using remove(). Other methods such as take() and poll() can also be used in a way to remove the first and the last elements.

Java

import java.util.concurrent.*;

public class GFG{
    
    public static void main(String[] args){
        
        BlockingQueue<Integer> queue = new LinkedBlockingDeque<>();

        queue.add(75);
        queue.add(86);
        queue.add(13);
        queue.add(44);
        queue.add(10);

        System.out.println("Before removing: " + queue);

        queue.remove(86);
        queue.remove(44);
        queue.remove(1); 

        System.out.println("After removing: " + queue);
    }
}

Output

Before removing: [75, 86, 13, 44, 10]
After removing: [75, 13, 10]

4. Iterating through the Elements

We can use an iterator to traverse the queue.

Java

import java.util.Iterator;
import java.util.concurrent.*;

public class GFG{
    
    public static void main(String[] args){
        
        BlockingQueue<Integer> queue = new LinkedBlockingDeque<>();

        queue.add(166);
        queue.add(246);
        queue.add(66);
        queue.add(292);
        queue.add(98);

        Iterator<Integer> iterator = queue.iterator();

        System.out.println("BlockingQueue elements:");
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
    }
}

Output

BlockingQueue elements:
166 246 66 292 98

Methods of BlockingQueue

Method	Description
void put(E e)	Inserts the specified element, waiting if necessary for space to become available.
E take()	Retrieves and removes the head element, waiting if necessary until an element becomes available.
boolean offer(E e)	Inserts the specified element immediately, returning false if the queue is full.
boolean offer(E e, long timeout, TimeUnit unit)	Inserts the element, waiting up to the specified time for space.
E poll()	Retrieves and removes the head element immediately, or returns null if the queue is empty.
E poll(long timeout, TimeUnit unit)	Retrieves and removes the head element, waiting up to the specified time if empty.
E peek()	Retrieves, but does not remove, the head element, or returns null if empty.
boolean add(E e)	Inserts the specified element immediately, throwing an exception if the queue is full.
boolean remove(Object o)	Removes a specific element from the queue if present.
boolean contains(Object o)	Checks if the specified element exists in the queue.
int remainingCapacity()	Returns the number of additional elements the queue can accept without blocking.
boolean isEmpty()	Checks if the queue contains no elements.
Iterator<E> iterator()	Returns an iterator over the elements in the queue in proper sequence.
E element()	Retrieves, but does not remove, the head element; throws NoSuchElementException if empty.

Comment

Explore

Basics

OOP & Interface

Collections

Advance Java Concepts

Practice Java

Courses

You are visitor 01402503 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.