LinkedBlockingQueue Class in Java (original) (raw)

Last Updated : 20 Feb, 2025

The **LinkedBlockingQueue in Java is part of the java.util.concurrent package and implements the BlockingQueue interface. It provides a thread-safe, bounded, or unbounded queue used for managing tasks in a producer-consumer scenario. This queue can be used in multithreaded environments where one thread produces data that other threads consume.

• This class is thread-safe.
• The queue supports blocking operations.
• If the constructor is provided with a capacity, it becomes a bounded queue, meaning the maximum number of elements it can hold is limited.
• If no capacity is provided, the queue is unbounded and can grow as required by the number of elements added.
• The LinkedBlockingQueue follows First In First Out (FIFO) ordering for both the insertion and removal of elements.

**Example: This example demonstrates how to insert elements into a LinkedBlockingQueue and print its contents.

Java `

// Java Program to demonstrate // how LinkedBlockingQueue works import java.util.concurrent.LinkedBlockingQueue;

public class Geeks { public static void main(String[] args) throws InterruptedException { // Create a LinkedBlockingQueue // with a capacity of 3 LinkedBlockingQueue q = new LinkedBlockingQueue<>(3);

    // Insert elements into the queue
    q.put("Geek 1");
    q.put("Geek 2");
    q.put("Geek 3");

    // Print the elements of the queue
    System.out.println("LinkedBlockingQueue is: ");
    for (String i : q) {
        System.out.println(i);
    }
}

}

`

Output

LinkedBlockingQueue is: Geek 1 Geek 2 Geek 3

LinkedBlockingQueue Hierarchy

Declaration of LinkedBlockingQueue

In Java, the declaration of LinkedBlockingQueue can be done as:

LinkedBlockingQueue queue = new LinkedBlockingQueue<>();

Note: Here the Type is the type of the element the queue will store(e.g String, Integer etc)

Constructors

**Example 1: This example demonstrates how to create a LinkedBlockingQueue and insert elements to it using the add() method.

Java `

// Java program to demonstrate // LinkedBlockingQueue() constructor import java.util.concurrent.LinkedBlockingQueue;

public class Geeks{

public static void main(String[] args)
{
    // create object of LinkedBlockingQueue 
    // using LinkedBlockingQueue() constructor 
    LinkedBlockingQueue<Integer> l
            = new LinkedBlockingQueue<Integer>();

    // add numbers 
    l.add(1);
    l.add(2);
    l.add(3);
 
    System.out.println("LinkedBlockingQueue:" + l);
}

}

`

Output

LinkedBlockingQueue:[1, 2, 3]

**Example 2: This example demonstrates how to create a LinkedBlockingQueue with a specified initial capacity and add elements to it.

Java `

// Java program to demonstrate // LinkedBlockingQueue(int initialCapacity) constructor import java.util.concurrent.LinkedBlockingQueue;

public class Geeks {

public static void main(String[] args)
{
    // define capacity of LinkedBlockingQueue
    int c = 15;

    // create object of LinkedBlockingQueue
    // using LinkedBlockingQueue(int initialCapacity)
    // constructor
    LinkedBlockingQueue<Integer> l
            = new LinkedBlockingQueue<Integer>(c);

    // add numbers
    l.add(1);
    l.add(2);
    l.add(3);

    // print queue
    System.out.println("LinkedBlockingQueue:" + l);
}

}

`

Output

LinkedBlockingQueue:[1, 2, 3]

**Example 3: This example demonstrates how to create a LinkedBlockingQueue using a collection like a vector to initialize the queue.

Java `

// Java program to demonstrate // LinkedBlockingQueue(Collection c) constructor import java.util.concurrent.LinkedBlockingQueue; import java.util.*;

public class Geeks {

public static void main(String[] args)
{
    // Creating a Collection
    Vector<Integer> v = new Vector<Integer>();
    v.addElement(1);
    v.addElement(2);
    v.addElement(3);

    // create object of LinkedBlockingQueue
    // using LinkedBlockingQueue(Collection c)
    // constructor
    LinkedBlockingQueue<Integer> l
            = new LinkedBlockingQueue<Integer>(v);

    // print queue
    System.out.println("LinkedBlockingQueue:" + l);
}

}

`

Output

LinkedBlockingQueue:[1, 2, 3]

Performing Various Operations on LinkedBlockingQueue

**1. Adding Elements: We can use add() method to insert elements in a LinkedBlockingQueue.

**Example: This example demonstrates how to create a LinkedBlockingQueue with a specified capacity of 15, add elements to the queueusing the add() and print the content of the queue.

Java `

// Java Program to Demonstrate adding // elements to the LinkedBlockingQueue import java.util.concurrent.LinkedBlockingQueue;

public class Geeks {

public static void main(String[] args)
{
    // define capacity of LinkedBlockingQueue
    int c = 15;

    // create object of LinkedBlockingQueue
    LinkedBlockingQueue<Integer> l
            = new LinkedBlockingQueue<Integer>(c);

    // add numbers
    l.add(1);
    l.add(2);
    l.add(3);

    // print queue
    System.out.println("LinkedBlockingQueue:" + l);
}

}

`

Output

LinkedBlockingQueue:[1, 2, 3]

**2. Remove Elements: We can use remove() method to remove elements from the LinkedBlockingQueue.

**Example: This example demonstrates how to remove a specified element from the queue using the remove().

Java `

// Java Program to demonstrate removing // elements from the LinkedBlockingQueue import java.util.concurrent.LinkedBlockingQueue;

public class Geeks {

public static void main(String[] args)
{
    // define capacity of LinkedBlockingQueue
    int c = 15;

    // create object of LinkedBlockingQueue
    LinkedBlockingQueue<Integer> l
            = new LinkedBlockingQueue<Integer>(c);

    // add numbers
    l.add(1);
    l.add(2);
    l.add(3);

    // print queue
    System.out.println("LinkedBlockingQueue:" + l);

    // remove element 2
    l.remove(2);

    // print queue
    System.out.println("Updated LinkedBlockingQueue:" + l);
}

}

`

Output

LinkedBlockingQueue:[1, 2, 3] Updated LinkedBlockingQueue:[1, 3]

**3. Iterating Elements: We can use the iterator() method of LinkedBlockingQueue which return an iterator that allows traversing through the elements of the queue.

**Example:

Java `

// Java Program Demonstrate iterating // over LinkedBlockingQueue import java.util.concurrent.LinkedBlockingQueue; import java.util.Iterator;

public class Geeks {

public static void main(String[] args)
{
    // define capacity of LinkedBlockingQueue
    int c = 7;

    // create object of LinkedBlockingQueue
    LinkedBlockingQueue<String> l
            = new LinkedBlockingQueue<String>(c);

    // Add element to LinkedBlockingQueue
    l.add("1");
    l.add("2");
    l.add("3");
    l.add("4");

    // create Iterator of linkedQueue using iterator() method
    Iterator<String> i = l.iterator();

    // print result
    System.out.println("Elements in the LinkedBlockingQueue: ");
    while (i.hasNext())
        System.out.print(i.next() + " ");
}

}

`

Output

Elements in the LinkedBlockingQueue: 1 2 3 4

**4. Accessing Elements: We can use peek() to retrieve the head of the LinkedBlockingQueue without removing it.

**Example:

Java `

// Java Program Demonstrate accessing // elements of LinkedBlockingQueue import java.util.concurrent.LinkedBlockingQueue; public class Geeks {

public static void main(String[] args)
{
    // define capacity of LinkedBlockingQueue
    int c = 7;

    // create object of LinkedBlockingQueue
    LinkedBlockingQueue<String> l
            = new LinkedBlockingQueue<String>(c);

    // Add element to LinkedBlockingQueue
    l.add("Java");
    l.add("C++");
    l.add("Python");
    l.add("Js");

    // find head of linkedQueue using peek() method
    String s = l.peek();

    // print result
    System.out.println("LinkedBlockingQueue: " + l);

    // print head of queue
    System.out.println("Head of LinkedBlockingQueue is: " + s);

    // removing one element
    l.remove();

    // again get head of queue
    s = l.peek();

    // print result
    System.out.println("Removing one element from Queue");
    System.out.println("Updated LinkedBlockingQueue is: " + l);

    // print head of queue
    System.out.println("Updated Head of LinkedBlockingQueue is: " + s);
}

}

`

**Output:

Methods

Methods declared in class java.util.AbstractCollection

Methods declared in class java.util.AbstractQueue

Methods declared in interface java.util.concurrent.BlockingQueue

Methods declared in interface java.util.Collection

Methods declared in interface java.util.Queue