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: ...