ConcurrentLinkedDeque in Java

The ConcurrentLinkedDeque class in Java is a part of the Java Collection Framework and implements the Collection interface and the AbstractCollection class. It belongs to java.util.concurrent package. It is used to implement Deque with the help of LinkedList concurrently.

• Iterators and spliterators are weakly consistent.
• Concurrent insertion, removal, and access operations execute safely across multiple threads.
• It does not permit null elements.
• size() method is not implemented in constant time. Because of the asynchronous nature of these deques, determining the current number of elements requires a traversal of the elements.

Example: This example demonstrates the usage of ConcurrentLinkedDeque to add and remove elements from both ends of the deque in a thread-safe manner.

First: 1, Last: 2

The ConcurrentLinkedDeque class in Java is a thread-safe implementation of the Deque interface that uses a linked list to store its elements. The ConcurrentLinkedDeque class provides a scalable and high-performance alternative to the ArrayDeque class, particularly in scenarios where multiple threads access the deque concurrently. The ConcurrentLinkedDeque class provides methods for inserting and removing elements from both ends of the deque, and for retrieving elements from the head and tail of the deque, making it a good choice for scenarios where you need to perform many add and remove operations.

ConcurrentLinkedDeque Hierarchy

The below diagram demonstrates the class and interface hierarchy of ConcurrentLinkedDeque showing how it extends AbstractCollecrtion, implements Deque and is a subclass of Queue, and also implements the Serializable interface

Declaration of ConcurrentLinkedDeque

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

ConcurrentLinkedDeque<Type> deque = new ConcurrentLinkedDeque<>();

Note: Here Type represents the type of element we want to store in the deque(e.g. Integer, String)

Constructors

Example: This example demonstrates how to create a ConcurrentLinkedDeque, add elements to the front, and create a copy of the deque.

Deque: [40, 30, 20, 10]
Deque Copy: [40, 30, 20, 10]

Example: This example demonstrates how to add elements to both ends of a ConcurrentLinkedDeque, access the first and last elements, and remove elements from both ends in a thread-safe manner.

Deque: [40, 30, 20, 10]
Last Element: 10
First Element: 40
Deque after removal of last element: [40, 30, 20]
Deque after removal of first element: [30, 20]

Performing Various Operations on ConcurrentLinkedDeque

1. Adding Elements: We can use methods like add(), addAll(), addFirst(), addLast() to insert elements to the ConcurrentLinkedDeque.

Example: This example demonstrates how to add elements to both end of a ConcurrentLinkedDeque and copy all elements from one deque to another.

Elements in d: [30, 10, 20]
Elements in d1: [30, 10, 20]

2. Removing Elements: We can use methods like remove(), remove(Object), removeFirst(), removeLast() to remove elements from the ConcurrentLinkedDeque.

Example:

Deque: [40, 50, 60, 70, 80]
Removing the first element: 40
60 removed?: true
Deque after removal: [50, 70, 80]
Deque after removing first and last element: [70]

3. Iterating Elements: We can use the iterator() or descendingIterator() method to iterate over the elements of the ConcurrentLinkedDeque.

Example:

Deque: [Java, C++, Python, Js]
Iterating over the elements of ConcurrentLinkedDeque: 
Java
C++
Python
Js

4. Accessing Elements: We can use methods like getFirst(), getLast(), element() to access the elements of the ConcurrentLinkedDeque.

Example:

Deque: [Java, C++, Python, Js]
First element: Java
Last element: Js
Head of deque: Java

Methods

Here, E is the type of element.

Methods Declared in Class java.util.AbstractCollection

Methods Declared in Interface java.util.Collection

Methods Declared in Interface java.util.Deque