BlockingDeque in Java

The BlockingDeque interface is a part of the Java Collections Framework. It gets its name because it blocks illegal operations such as insertion into a full queue or deletion from an empty queue, all of these properties are inbuilt into the structure of this interface. Since it is a deque (double-ended queue) that is the insertion, deletion, and traversal operations can be performed from both ends. The BlockingDeque is an interface, so we cannot declare any objects with it.

Hierarchy

The BlockingDeque extends from the BlockingQueue interface, which in turn extends from the Queue interface and the Deque interface.

The Hierarchy of BlockingDeque

Note: The Interfaces of the Collection framework may have additional implementing classes and extending interfaces but the above image only shows the hierarchy of BlockingDeque and its implementing classes.

Syntax:

public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E>

Here, E is the type of elements in the collection.

Classes that Implement BlockingDeque

The implementing class of BlockingDeque is LinkedBlockingDeque. This class is the implementation of the BlockingDeque and the linked list data structure. The LinkedBlockingDeque can be optionally bounded using a constructor, however, if the capacity is unspecified it is Integer.MAX_VALUE by default. The nodes are added dynamically at the time of insertion obeying the capacity constraints.  To use BlockingDeque in your code, use this import statement.

import java.util.concurrent.BlockingDeque;
                    (or)
import java.util.concurrent.*;

The syntax for creating objects:

LinkedBlockingDeque<?> objectName = new LinkedBlockingDeque<?>();
                (or)
BlockingDeque<?> objectName = new LinkedBlockingDeque<?>();

Example: In the code given below we perform some basic operations on a LinkedBlockingDeque, like creating an object, adding elements, deleting elements, and using an iterator to traverse through the LinkedBlockingDeque.

Output:

The LinkedBlockingDeque lbdq contains:
134 245 23 122 90 

The element 23 has been removed

The LinkedBlockingDeque lbdq after remove operation contains:
[134, 245, 122, 90]

Basic Operations

1. Adding Elements

Elements can be added into a LinkedBlockedDeque in different ways depending on the type of structure we are trying to use it as. The most common method is the add() method using which we can add elements at the end of the deque. We can also use the addAll() method (which is a method of the Collection interface) to add an entire collection to LinkedBlockingDeque. If we wish to use the deque as a queue we can use add() and put().

Contents of lbdq1: [145, 89, 65, 122, 11]

Contents of lbdq2: [145, 89, 65, 122, 11]

2. Accessing Elements

The elements of the LinkedBlockingDeque can be accessed using contains(), element(), peek(), poll(). There are variations of these methods too which are given in the table above along with their descriptions.

The LinkedBlockingDeque, lbdq contains:
[22, 125, 723, 172, 100]
The LinkedBlockingDeque, lbdq contains 22
The head of lbdq: 22
The tail of lbdq: 100

3. Deleting Elements

Elements can be deleted from a LinkedBlockingDeque using remove(). Other methods such as take() and poll() can also be used in a way to remove the first and the last elements.

The LinkedBlockingDeque, lbdq contains:
[75, 86, 13, 44, 10]

The LinkedBlockingDeque, lbdq contains:
[75, 13, 10]

4. Iterating through the Elements

To iterate through the elements of a LinkedBlockingDeque we can create an iterator and use the methods of the Iterable interface, which is the root of the Collection Framework of Java, to access the elements. The next() method of Iterable returns the element of any collection.

The LinkedBlockingDeque, lbdq contains:
166 246 66 292 98 

Methods of BlockingDeque

The BlockingDeque interface has a various method which has to be defined by every implementing class. A deque can be implemented as a queue and as a stack, therefore the BlockingDeque interface provides methods to do the same. The table below provides a list of all the methods and their function.

Here, 

• E – The type of elements in the collection.
• TimeUnit – An enum that represents the time durations.

Methods declared in interface java.util.concurrent.BlockingQueue

Methods declared in interface java.util.Collection

Methods declared in interface java.util.Deque

Methods declared in interface java.lang.Iterable

The behavior of BlockingDeque Methods

The following are the methods provided by the BlockingDeque for insertion, removal, and examine operations on the deque. Each of the four sets of methods behaves differently if the requested operation is not satisfied immediately. 

• Throws Exception: An exception will be thrown, if the requested operation is not satisfied immediately.
• Special value: A special value is returned if the operation is not satisfied immediately.
• Blocks: The method call is blocked if the attempted operation is not satisfied immediately and it waits until it gets executed.
• Times out: A special value is returned telling whether the operation succeeded or not. If the requested operation is not possible immediately, the method call blocks until it is, but waits no longer than the given timeout. 

We know that we can insert, remove, and examine elements from both directions in the BlockingDeque. Since BlockingDeque extends BlockingQueue, the methods for insertion, removal, and examination operations acting on a direction on BlockingDeque are similar to BlockingQueue. The following comparison explains the same.

Reference: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/BlockingDeque.html