ConcurrentLinkedQueue in Java
In Java, the ConcurrentLinkedQueue is the part of the java.util.concurrent package and implements a FIFO(First-In-First-Out) queue. It is a thread-safe, non-blocking, and scalable queue designed for use in highly concurrent environments. The queue uses a lock-free algorithm, ensuring that multiple threads can safely enqueue and dequeue elements without the need for external synchronization.
- The queue allows multiple threads to perform operations without locking
- It can be accessed by multiple threads concurrently without causing data corruption
- The queue maintains the order of elements as they are added
Example: This example demonstrates creating a thread-safe ConcurrentLinkedQueue, adding elements to it and printing the queue.
// Java Program to demonstrate the working of
// ConcurrentLinkedQueue
import java.util.concurrent.ConcurrentLinkedQueue;
public class Geeks {
public static void main(String[] args)
{
// Create a ConcurrentLinkedQueue
ConcurrentLinkedQueue<Integer> q
= new ConcurrentLinkedQueue<>();
// Adding elements to the queue
q.offer(1);
q.offer(2);
q.offer(3);
System.out.println("Queue after adding elements: "
+ q);
}
}
Output
Queue after adding elements: [1, 2, 3]
Hierarchy of ConcurrentLinkedQueue
java.lang.Object
↳ java.util.AbstractCollection<E>
↳ java.util.AbstractQueue<E>
↳ Class ConcurrentLinkedQueue<E>
Declaration of ConcurrentLinkedQueue
In Java, the declaration of ConcurrentLinkedQueue can be done as:
ConcurrentLinkedQueue<Type> queueName = new ConcurrentLinkedQueue<>();
Constructors
Constructor | Description |
|---|---|
ConcurrentLinkedQueue() | It is used to construct an empty queue. |
ConcurrentLinkedQueue(Collection<E> c) | It is used to construct a queue with the elements of the Collection passed as the parameter. |
Example 1: This example demonstrates creating and initializing a ConcurrentLinkedQueue both with individual elements and by copying another queue using a constructor.
// Java Program demonstrating both with individual elements
// and by copying another queue using a constructor
import java.util.concurrent.*;
class Geeks {
public static void main(String[] args)
{
// Create a ConcurrentLinkedQueue
// using ConcurrentLinkedQueue() constructor
ConcurrentLinkedQueue<Integer> q
= new ConcurrentLinkedQueue<Integer>();
q.add(10);
q.add(20);
q.add(30);
q.add(40);
// Displaying the existing ConcurrentLinkedQueue
System.out.println("ConcurrentLinkedQueue: " + q);
// Create a ConcurrentLinkedQueue
// using ConcurrentLinkedQueue(Collection c)
// constructor
ConcurrentLinkedQueue<Integer> q1
= new ConcurrentLinkedQueue<Integer>(q);
// Displaying the existing ConcurrentLinkedQueue
System.out.println("ConcurrentLinkedQueue1: " + q1);
}
}
Output
ConcurrentLinkedQueue: [10, 20, 30, 40] ConcurrentLinkedQueue1: [10, 20, 30, 40]
Example 2: This example demonstrates the use of ConcurrentLinkedQueue methods like peek(), poll() and size() to interact with and manipulate the queue.
// Java Program to demosntrates the
// working of peek(), poll(), size()
import java.util.concurrent.*;
class Geeks {
public static void main(String[] args)
{
// Create a ConcurrentLinkedQueue
// using ConcurrentLinkedQueue()
// constructor
ConcurrentLinkedQueue<Integer>
q = new ConcurrentLinkedQueue<Integer>();
q.add(10);
q.add(20);
q.add(30);
q.add(40);
System.out.println("ConcurrentLinkedQueue: "
+ q);
// Displaying the first element
// using peek() method
System.out.println("First Element is: "
+ q.peek());
// Remove and display the first element
// using poll() method
System.out.println("Head Element is: "
+ q.poll());
// Displaying the existing ConcurrentLinkedQueue
System.out.println("ConcurrentLinkedQueue: "
+ q);
// Get the size using size() method
System.out.println("Size: "
+ q.size());
}
}
Output
ConcurrentLinkedQueue: [10, 20, 30, 40] First Element is: 10 Head Element is: 10 ConcurrentLinkedQueue: [20, 30, 40] Size: 3
Performing Various Operations on ConcurrentLinkedQueue
1. Adding Elements: We use add() and addAll() method to insert elements in a ConcurrentLinkedQueue.
Example: This example demonstrates how to add individual elements and a collection of elements to a ConcurrentLinkedQueue using add() and addAll().
// Java Program to demonstrate adding
// elements to ConcurrentLinkedQueue
// using add() and addAll() method
import java.util.*;
import java.util.concurrent.*;
public class Geeks {
public static void main(String[] args)
{
// Create an instance of ConcurrentLinkedQueue
ConcurrentLinkedQueue<String> q
= new ConcurrentLinkedQueue<String>();
// Add String to queue using add method
q.add("Java");
q.add("C++");
q.add("Python");
q.add("Js");
// Displaying the existing ConcurrentLinkedQueue
System.out.println("ConcurrentLinkedQueue: " + q);
// create a ArrayList of Strings
ArrayList<String> al = new ArrayList<String>();
// add String to ArrayList
al.add("Geek1");
al.add("Geek2");
al.add("Geek3");
al.add("Geek4");
al.add("Geek5");
// Displaying the existing Collection
System.out.println("Collection to be added: " + al);
// apply addAll() method and passed
// the arraylist as parameter
boolean b = q.addAll(al);
// Displaying the existing ConcurrentLinkedQueue
System.out.println("Collection added: " + b);
// Displaying the existing ConcurrentLinkedQueue
System.out.println("ConcurrentLinkedQueue: " + q);
}
}
Output:
2. Removing Elements: We can use remove() to remove elements from the ConcurrentLinkedQueue.
Example: This example demonstrates how to remove a specific element from a ConcurrentLinkedQueue using the remove() method.
// Java Program to Demonstrate the
// working of remove() method
import java.util.concurrent.*;
public class Geeks {
public static void main(String[] args)
{
// Create an instance of ConcurrentLinkedQueue
ConcurrentLinkedQueue<Integer> q
= new ConcurrentLinkedQueue<Integer>();
// Add Numbers to queue using add(e) method
q.add(10);
q.add(20);
q.add(30);
q.add(40);
System.out.println("ConcurrentLinkedQueue: " + q);
// apply remove() for Number 78249
boolean b = q.remove(20);
System.out.println(
"number 20 remove successfully? : " + b);
// Displaying the existing ConcurrentLinkedQueue
System.out.println("Updated ConcurrentLinkedQueue: "
+ q);
}
}
Output
ConcurrentLinkedQueue: [10, 20, 30, 40] number 20 remove successfully? : true Updated ConcurrentLinkedQueue: [10, 30, 40]
3. Iterating Elements: We can use the iterator() method of ConcurrentLinkedQueue which return an iterator that allows traversing through the elements of the queue in the FIFO order.
Example: This example demonstrates how to use the iterator() method of ConcurrentLinkedQueue to traverse and print its elements in FIFO order.
// Java Program Demonstrate the
// working of iterator() method
import java.util.*;
import java.util.concurrent.*;
public class Geeks {
public static void main(String[] args)
{
// Create an instance of ConcurrentLinkedQueue
ConcurrentLinkedQueue<String> q
= new ConcurrentLinkedQueue<String>();
// Add String to queue using add(e) method
q.add("Java");
q.add("C++");
q.add("Python");
q.add("js");
// Displaying the existing ConcurrentLinkedQueue
System.out.println("ConcurrentLinkedQueue: " + q);
// Call iterator() method
Iterator i = q.iterator();
// Print elements of iterator
System.out.println(
"The String Values of iterator are:");
while (i.hasNext()) {
System.out.print(i.next() + " ");
}
}
}
Output
ConcurrentLinkedQueue: [Java, C++, Python, js] The String Values of iterator are: Java C++ Python js
4. Accessing Elements: We can use peek() and element() to access the elements of ConcurrentLinkedQueue.
Example: This example demonstrates how to access the head element of a ConcurrentLinkedQueue using element() and peek() method.
// Java Program Demonstrate the
// working of element() and peek()
import java.util.concurrent.*;
public class Geeks {
public static void main(String[] args)
throws IllegalStateException
{
// Create an instance of ConcurrentLinkedQueue
ConcurrentLinkedQueue<Integer> q
= new ConcurrentLinkedQueue<>();
// Add numbers to end of Queue
q.add(10);
q.add(20);
q.add(30);
q.add(40);
System.out.println("Queue: " + q);
// print head using element()
System.out.println("Queue's head: " + q.element());
// print head using peek()
System.out.println("Queue's head: " + q.peek());
}
}
Output
Queue: [10, 20, 30, 40] Queue's head: 10 Queue's head: 10
Methods of ConcurrentLinkedQueue
Method | Description |
|---|---|
| add(E e) | Inserts the specified element at the tail of this queue. |
| addAll(Collection<? extends E> c) | Appends all of the elements in the specified collection to the end of this queue, in the order that they are returned by the specified collection’s iterator. |
| contains(Object o) | Returns true if this queue contains the specified element. |
| forEach(Consumer<? super E> action) | Performs the given action for each element of the Iterable until all elements have been processed or the action throws an exception. |
| isEmpty() | Returns true if this queue contains no elements. |
| iterator() | Returns an iterator over the elements in this queue in the proper sequence. |
| offer(E e) | Inserts the specified element at the tail of this queue. |
| remove(Object o) | Removes a single instance of the specified element from this queue, if it is present. |
| removeAll(Collection<?> c) | Removes all of this collection’s elements that are also contained in the specified collection (optional operation). |
| removeIf(Predicate<? super E> filter) | Removes all of the elements of this collection that satisfy the given predicate. |
| retainAll(Collection<?> c) | Retains only the elements in this collection that are contained in the specified collection (optional operation). |
| size() | Returns the number of elements in this queue. |
| spliterator() | Returns a Spliterator over the elements in this queue. |
| toArray() | Returns an array containing all of the elements in this queue, in the proper sequence. |
| toArray(T[] a) | Returns an array containing all of the elements in this queue, in proper sequence; the runtime type of the returned array is that of the specified array. |
Methods Declared in Class java.util.AbstractQueue
Methods | Description |
|---|---|
| clear() | Removes all the elements from this queue. |
| element() | Retrieves, but does not remove, the head of this queue. |
| remove() | Retrieves and removes the head of this queue. |
Methods Declared in Class java.util.AbstractCollection
Method | Description |
|---|---|
| containsAll(Collection<?> c) | Returns true if this collection contains all of the elements in the specified collection. |
| toString() | Returns a string representation of this collection. |
Methods Declared in Interface java.util.Collection
Method | Description |
|---|---|
| clear() | Removes all of the elements from this collection (optional operation). |
| containsAll(Collection<?> c) | Returns true if this collection contains all of the elements in the specified collection. |
| equals(Object o) | Compares the specified object with this collection for equality. |
| hashCode() | Returns the hash code value for this collection. |
| parallelStream() | Returns a possibly parallel Stream with this collection as its source. |
| stream() | Returns a sequential Stream with this collection as its source. |
| toArray(IntFunction<T[]> generator) | Returns an array containing all of the elements in this collection, using the provided generator function to allocate the returned array. |
Methods Declared in Interface java.util.Queue
Method | Description |
|---|---|
| element() | Retrieves, but does not remove, the head of this queue. |
| peek() | Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty. |
| poll() | Retrieves and removes the head of this queue, or returns null if this queue is empty. |
| remove() | Retrieves and removes the head of this queue. |
