How to Create a Thread-Safe Queue in Java?

Last Updated : 04 Mar, 2024

In Java, thread-safe is defined as the Queue data structure and it allows multiple threads to safely add and remove elements from the queue concurrently without any data corruption. In a multithreaded environment, the threads access and modify the shared data concurrently, and it is important to ensure that operations on the queue are synchronized to avoid race conditions.

In this article, we will learn how to create a Thread-Safe Queue in Java.

Step-by-Step Implementation

Create the class named the ThreadSafeQueueExample and write the main method into it.
Create the instance of the ConcurrentLinkedQueue using Queue and it is named as the threadSafeQueue.
First, we can add the elements into the threadSafeQueue then poll the element and print it.
Now, we can define the producer and consumer runnable and implement the logic of both producer and consumer.
Create the thread instance of the producer and consumer then start both threads.
Print the remaining elements in the queue.

Program to Create a Thread-Safe Queue in Java

Java

// Java program to create a Thread-Safe Queue import java.util.Queue; import java.util.concurrent.ConcurrentLinkedQueue; // Driver Class public class ThreadSafeQueueExample  {  // Main Method  public static void main(String args[])   {  // Create a ConcurrentLinkedQueue instance  Queue<String> threadSafeQueue = new ConcurrentLinkedQueue<>();  // Adding elements to the queue  threadSafeQueue.add("Element 1");  threadSafeQueue.add("Element 2");  threadSafeQueue.add("Element 3");  // Removing elements from the queue  String element = threadSafeQueue.poll();  System.out.println("Removed element: " + element);  // Accessing the queue safely from multiple threads  Runnable producer = () -> {  for (int i = 0; i < 5; i++) {  threadSafeQueue.add("New Element " + i);  System.out.println("Added New Element " + i);  }  };  Runnable consumer = () -> {  while (!threadSafeQueue.isEmpty()) {  String item = threadSafeQueue.poll();  System.out.println("Consumed: " + item);  }  };  // Create multiple threads to access the queue concurrently  Thread producerThread = new Thread(producer);  Thread consumerThread = new Thread(consumer);  producerThread.start();  consumerThread.start();  try {  producerThread.join();  consumerThread.join();  } catch (InterruptedException e) {  e.printStackTrace();  }  // Printing the remaining elements in the queue  System.out.println("Remaining elements in the queue: " + threadSafeQueue);  } }

Output

Removed element: Element 1 Consumed: Element 2 Consumed: Element 3 Added New Element 0 Added New Element 1 Added New Element 2 Added New Element 3 Added New Element 4 Remaining elements in the queue: ...

Explanation of the above Program:

We have used a ConcurrentLinkedQueue to create a thread-safe queue.
Then we have added elements and removed from the queue safely.
Now, we have created two threads.
First one acts as a producer to add elements to the queue, and the second one acts as a consumer to consume elements from the queue.
After the threads complete their operations, it prints the queue.