Java LinkedBlockingQueue

August 4, 2023

What is Java LinkedBlockingQueue?

Java LinkedBlockingQueue is a class in the Java Collections Framework that implements the BlockingQueue interface.
It is a thread-safe data structure that allows multiple threads to access and manipulate a queue of elements. Elements are added to the back of the queue, and removed from the front of the queue.
LinkedBlockingQueue is based on a linked node structure, where each node in the queue contains an element and a reference to the next node.
To understand the Java LinkedBlockingQueue, Read the Complete Article.

Steps to Create Java LinkedBlockingQueue

1. Import the LinkedBlockingQueue class:

import java.util.concurrent.LinkedBlockingQueue;

2. Create an instance of the LinkedBlockingQueue class:

LinkedBlockingQueue queue = new LinkedBlockingQueue<>();

3. Add elements to the queue using the add() method:

queue.add("Element 1");
queue.add("Element 2");

4. Alternatively, you can use the put() method to add elements to the queue. The put() method will block if the queue is full:

queue.put("Element 3");

5. Remove elements from the queue using the remove() method:

String element = queue.remove();

5.Alternatively, you can use the take() method to remove elements from the queue. The take() method will block if the queue is empty:

String element = queue.take();

Methods of LinkedBlockingQueue

add(E e): Adds the specified element to the end of the queue. Throws an exception if the queue is full.
offer(E e): Adds the specified element to the end of the queue. Returns true if the element was added successfully, false otherwise.
put(E e): Adds the specified element to the end of the queue. If the queue is full, blocks until space becomes available.
take(): Removes and returns the head of the queue. If the queue is empty, blocks until an element becomes available.
poll(): Removes and returns the head of the queue, or returns null if the queue is empty.
peek(): Returns the head of the queue without removing it, or returns null if the queue is empty.
size(): Returns the number of elements in the queue.
remainingCapacity(): Returns the number of additional elements that the queue can hold.
contains(Object o): Returns true if the queue contains the specified element, false otherwise.
remove(Object o): Removes the first occurrence of the specified element from the queue, if it is present.
toArray(): Returns an array containing all of the elements in the queue, in the same order as they appear in the queue.
clear(): Removes all elements from the queue.

Introduction to java

static variable in java

If statement in Java

Switch Statement in Java

Abstraction in Java

Let’s look at the Java LinkedBlockingQueue to perform certain operations.

Example 1: Java Program to Insert Elements in LinkedBlockingQueue

Run

import java.util.concurrent.LinkedBlockingQueue;

public class Main{
  public static void main(String[] args) {
  
    // Create a LinkedBlockingQueue
    LinkedBlockingQueue queue = new LinkedBlockingQueue();
    
    // Add elements to the queue
    queue.add("element 1");
    queue.add("element 2");
    queue.add("element 3");
    
    // Print the elements in the queue
    System.out.println("Elements in the queue:");
    for (String element : queue) {
      System.out.println(element);
    }
  }
}

Output

Elements in the queue:
element 1
element 2
element 3

Explanation:

In this example, we create a LinkedBlockingQueue and add three elements to it using the add method. We then print the elements in the queue using a for loop that iterates over the elements in the queue.

Note that the LinkedBlockingQueue class implements the Iterable interface, which means that you can use a for loop to iterate over the elements in the queue.

Example 2 : Java Program to remove Elements in LinkedBlockingQueue

Run

import java.util.concurrent.LinkedBlockingQueue;

public class Main {
  public static void main(String[] args) {
  
    // Create a LinkedBlockingQueue
    LinkedBlockingQueue queue = new LinkedBlockingQueue();
    
    // Add elements to the queue
    queue.add("element 1");
    queue.add("element 2");
    queue.add("element 3");
    
    // Remove elements from the queue
    String element1 = queue.poll();
    String element2 = queue.poll();
    String element3 = queue.poll();
    
    // Print the removed elements
    System.out.println("Removed elements:");
    System.out.println(element1);
    System.out.println(element2);
    System.out.println(element3);
    
    // Print the elements remaining in the queue
    System.out.println("Elements remaining in the queue:");
    for (String element : queue) {
      System.out.println(element);
    }
  }
}

Output

Removed elements:
element 1
element 2
element 3
Elements remaining in the queue:

Explanation:

In this example, we create a LinkedBlockingQueue and add three elements to it using the add method. We then remove the elements from the queue using the poll method and store them in variables.

We print the removed elements using System.out.println statements, and then print the elements remaining in the queue using a for loop that iterates over the elements in the queue.

Example 3:Java Program to Access Elements in LinkedBlockingQueue

Run

import java.util.concurrent.LinkedBlockingQueue;

public class Main {
  public static void main(String[] args) {
  
    // Create a LinkedBlockingQueue
    LinkedBlockingQueue queue = new LinkedBlockingQueue();
    
    // Add elements to the queue
    queue.add("element 1");
    queue.add("element 2");
    queue.add("element 3");
    
    // Access the head element of the queue
    String headElement = queue.peek();
    
    // Print the head element
    System.out.println("Head element: " + headElement);
    
    // Check if the queue contains a specific element
    boolean containsElement2 = queue.contains("element 2");
    
    // Print the result
    if (containsElement2) {
      System.out.println("The queue contains element 2");
    } else {
      System.out.println("The queue does not contain element 2");
    }
  }
}

Output

Head element: element 1
The queue contains element 2

Explanation:

In this example, we create a LinkedBlockingQueue and add three elements to it using the add method. We then access the head element of the queue using the peek method and store it in a variable. We print the head element using a System.out.println statement.

We then check if the queue contains a specific element using the contains method and store the result in a boolean variable. We print the result using a System.out.println statement.

This shows that we were able to access elements in the queue using the peek and contains methods. Note that the peek method returns null if the queue is empty, so it's a good idea to check if the result is null before using it.

Java put() and take() Methods

Example 4: Java Program to Take() Method in Java LinkedBlockingQueue

Run

import java.util.concurrent.LinkedBlockingQueue;

public class Main {
  public static void main(String[] args) throws InterruptedException {
  
    // Create a LinkedBlockingQueue
    LinkedBlockingQueue queue = new LinkedBlockingQueue();
    
    // Add elements to the queue
    queue.add("element 1");
    queue.add("element 2");
    queue.add("element 3");
    
    // Take elements from the queue using take() method
    String element1 = queue.take();
    String element2 = queue.take();
    String element3 = queue.take();
    
    // Print the elements
    System.out.println("Element 1: " + element1);
    System.out.println("Element 2: " + element2);
    System.out.println("Element 3: " + element3);
  }
}

Output

Element 1: element 1
Element 2: element 2
Element 3: element 3

Explanation:

In this example, we create a LinkedBlockingQueue and add three elements to it using the add method. We then use the take method to remove elements from the queue and store them in variables. The take method blocks (i.e., waits) until an element becomes available in the queue.

We then print the three elements using System.out.println statements.

This shows that we were able to use the take method to remove elements from the queue in the correct order.

Note that if the queue is empty, the take method will block until an element becomes available. In this case, it's a good idea to use a try-catch block to handle the InterruptedException that may be thrown by the take method

Example 5: Java Program to use Put() Method in LinkedBlockingQueue

Run

import java.util.concurrent.LinkedBlockingQueue;

public class Main {
  public static void main(String[] args) throws InterruptedException {
  
    // Create a LinkedBlockingQueue with capacity 2
    LinkedBlockingQueue queue = new LinkedBlockingQueue(2);
    
    // Add elements to the queue using put() method
    queue.put("element 1");
    System.out.println("Added element 1");
    queue.put("element 2");
    System.out.println("Added element 2");
    
    // Try to add a third element to the queue using put() method
    System.out.println("Trying to add element 3...");
    queue.put("element 3");
    
    // This line won't be reached because the previous line will block
    System.out.println("Added element 3");
  }
}

Output

LinkedHashMap:
Apple: 1
Samsung: 2
Nokia: 3

HashMap:
Apple: 1
Samsung: 2
Nokia: 3

Explanation:

In this example, we create a LinkedBlockingQueue with a capacity of 2 and add two elements to it using the put method. We then try to add a third element to the queue using put. Since the queue is already full, the put method will block (i.e., wait) until space becomes available in the queue. This shows that the first two elements were added to the queue successfully, and that the put method blocked when we tried to add a third element.

Note that if the queue is full, the put method will block until space becomes available. In this case, it's a good idea to use a try-catch block to handle the InterruptedException that may be thrown by the put method.

Why use LinkedBlockingQueue?

Java LinkedBlockingQueue is a thread-safe implementation of the BlockingQueue interface in Java, which means that it can be used in multi-threaded applications where multiple threads may need to add or remove elements from the queue simultaneously.

Some reasons to use LinkedBlockingQueue are:

Thread safety: As mentioned above, LinkedBlockingQueue is thread-safe, which means that multiple threads can access the queue at the same time without causing any concurrency issues.
Blocking behavior: LinkedBlockingQueue is a blocking queue, which means that if a thread tries to remove an element from an empty queue, it will block (i.e., wait) until an element becomes available. Similarly, if a thread tries to add an element to a full queue, it will block until there is space available in the queue. This can be useful in scenarios where you want to control the flow of data between threads.
FIFO ordering: LinkedBlockingQueue maintains the order of elements in the queue according to first-in, first-out (FIFO) ordering. This means that the order in which elements are added to the queue is preserved when they are removed.
No size limit: LinkedBlockingQueue can grow dynamically as needed, which means that there is no fixed limit to the number of elements that can be added to the queue. This can be useful in scenarios where you don’t know the maximum number of elements that will be added to the queue.

Overall, LinkedBlockingQueue is a versatile and flexible data structure that can be useful in a wide range of multi-threaded applications.

Prime Course Trailer

Related Banners

Get PrepInsta Prime & get Access to all 200+ courses offered by PrepInsta in One Subscription

Get over 200+ course One Subscription

Courses like AI/ML, Cloud Computing, Ethical Hacking, C, C++, Java, Python, DSA (All Languages), Competitive Coding (All Languages), TCS, Infosys, Wipro, Amazon, DBMS, SQL and others

Java LinkedBlockingQueue

What is Java LinkedBlockingQueue?

Steps to Create Java LinkedBlockingQueue

Let’s look at the Java LinkedBlockingQueue to perform certain operations.

Example 1: Java Program to Insert Elements in LinkedBlockingQueue

Output

Example 2 : Java Program to remove Elements in LinkedBlockingQueue

Output

Example 3:Java Program to Access Elements in LinkedBlockingQueue

Output

Java put() and take() Methods

Example 4: Java Program to Take() Method in Java LinkedBlockingQueue

Output

Example 5: Java Program to use Put() Method in LinkedBlockingQueue

Output

Why use LinkedBlockingQueue?

Prime Course Trailer

Related Banners

Get over 200+ course One Subscription

Checkout list of all the video courses in PrepInsta Prime Subscription

Checkout list of all the video courses in PrepInsta Prime Subscription