Java Program to Implement LinkedBlockingDeque API

The LinkedBlockingDeque class introduced in JDK 1.6 is present in java.util.concurrent package. It is a deque which means a doubly ended queue. The default size of  LinkedBlockingDeque is Integer.MAX_VALUE. It implements the BlockingDeque class and provides an optionally-bounded functionality based on linked nodes. This optional boundedness is served by passing the required size in the constructor and helps in preventing memory wastage. This class blocks a thread if that thread tries to remove elements out of an empty deque.

It implements Serializable, Iterable<E>, Collection<E>, BlockingDeque<E>, BlockingQueue<E>, Deque<E>, Queue<E> interfaces and extends AbstractQueue<E> and AbstractCollection<E> classes.

Declaration:

public class LinkedBlockingDeque<E> extends AbstractQueue<E> implements 
BlockingDeque<E>, Serializable

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

Implementation of LinkedBlockingDeque API :

Java

// Java program to show the implementation
// of LinkedBlockingDeque API

import java.util.*;
import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;

class LinkedBlockingDequeImpl<E> {
    private LinkedBlockingDeque<E> linkedBlockingDeque;

    // constructor to create a LinkedBlockingDeque .
    public LinkedBlockingDequeImpl()
    {
        linkedBlockingDeque = new LinkedBlockingDeque<E>();
    }

    // constructor to create a LinkedBlockingDeque initially
    // containing the elements of the given collection
    public LinkedBlockingDequeImpl(
        Collection<? extends E> collection)
    {
        linkedBlockingDeque
            = new LinkedBlockingDeque<E>(collection);
    }

    // constructor to create a LinkedBlockingDeque with
    // specified capacity.
    public LinkedBlockingDequeImpl(int cap)
    {
        linkedBlockingDeque
            = new LinkedBlockingDeque<E>(cap);
    }

    // method to remove all of the elements from the deque.
    public void clear() { linkedBlockingDeque.clear(); }

    // method to check if deque contains the specified
    // element.
    public boolean contains(Object object)
    {
        return linkedBlockingDeque.contains(object);
    }

    // method to remove all of the elements from the deque
    // and add them to specified collection.
    public int drainTo(Collection<? super E> collection)
    {
        return linkedBlockingDeque.drainTo(collection);
    }

    // method to remove specified number of the elements
    // from the deque and add them to specified collection.
    public int drainTo(Collection<? super E> collection,
                       int maxElement)
    {
        return linkedBlockingDeque.drainTo(collection,
                                           maxElement);
    }

    // method to return an iterator over the elements in
    // this deque .
    public Iterator<E> iterator()
    {
        return linkedBlockingDeque.iterator();
    }

    // method to insert a specified element at the tail of
    // this queue. Return true upon successful insertion
    // else return false.
    public boolean offer(E element)
    {
        return linkedBlockingDeque.offer(element);
    }

    // method to insert a specified element at the tail of
    // this queue. Return true upon successful insertion
    // else return false.
    public boolean offer(E element, long timeout,
                         TimeUnit unit)
        throws InterruptedException
    {
        return linkedBlockingDeque.offer(element, timeout,
                                         unit);
    }

    // method to retrieve element from head of deque .
    public E peek() { return linkedBlockingDeque.peek(); }

    // method to remove and retrieve element from head of
    // deque .
    public E poll() { return linkedBlockingDeque.poll(); }

    // method to remove and retrieve element from head of
    // deque .
    public E poll(long timeout, TimeUnit unit)
        throws InterruptedException
    {
        return linkedBlockingDeque.poll(timeout, unit);
    }

    // method to insert the specified element at the tail of
    // the deque.
    public void put(E element) throws InterruptedException
    {
        linkedBlockingDeque.put(element);
    }

    // method to return the number of additional elements
    // that the deque can ideally accept without blocking.
    public int remainingCapacity()
    {
        return linkedBlockingDeque.remainingCapacity();
    }

    // method to remove a single instance of the
    // specified element from the deque
    public boolean remove(Object object)
    {
        return linkedBlockingDeque.remove(object);
    }

    // method to return the number of elements in the deque.
    public int size() { return linkedBlockingDeque.size(); }

    // method to retrieve and remove the head of the deque.
    public E take() throws InterruptedException
    {
        return linkedBlockingDeque.take();
    }

    // method to return an array containing all of
    // the elements in the deque.
    public Object[] toArray()
    {
        return linkedBlockingDeque.toArray();
    }

    // method to return an array containing all of
    // the elements in the deque
    public <T> T[] toArray(T[] array)
    {
        return linkedBlockingDeque.toArray(array);
    }

    // method to return a string representation of the
    // collection
    public String toString()
    {
        return linkedBlockingDeque.toString();
    }

    // method to insert specified element at the front of
    // the deque.
    public void addFirst(E element)
    {
        linkedBlockingDeque.addFirst(element);
    }

    // method to insert specified element at the end of the
    // deque.
    public void addLast(E element)
    {
        linkedBlockingDeque.addLast(element);
    }

    // method to retrieve first element of the deque.
    public void getFirst()
    {
        linkedBlockingDeque.getFirst();
    }

    // method to retrieve the last element of the deque.
    public void getLast() { linkedBlockingDeque.getLast(); }

    // Inserts the specified element at the front of this
    // deque
    public boolean offerFirst(E element)
    {
        return linkedBlockingDeque.offerFirst(element);
    }

    // method to insert a specified element at the end of
    // the deque.
    public boolean offerLast(E element)
    {
        return linkedBlockingDeque.offerLast(element);
    }

    // method to retrieve first element of the deque .
    public E peekFirst()
    {
        return linkedBlockingDeque.peekFirst();
    }

    // method to retrieve last element of the deque .
    public E peekLast()
    {
        return linkedBlockingDeque.peekLast();
    }
}

public class LinkedBlockingDequeDemo {
    public static void main(String[] args)
        throws InterruptedException
    {

        // create object of LinkedBlockingDeque
        // using LinkedBlockingDeque() constructor
        LinkedBlockingDequeImpl<Integer> linkedBlockingDeque
            = new LinkedBlockingDequeImpl<Integer>();

        try {

            // Add numbers to end of LinkedBlockingDeque
            linkedBlockingDeque.put(10);
            linkedBlockingDeque.put(20);
            linkedBlockingDeque.put(30);
        }

        catch (InterruptedException e)
        {
            e.printStackTrace();
        }

        System.out.println(
            "the elements of the linkedBlockingDeque is ");

        Iterator<Integer> itr = linkedBlockingDeque.iterator();

        while (itr.hasNext())
        {
            System.out.print(itr.next() + "\t");
        }

        System.out.println();

        linkedBlockingDeque.offer(60);
        linkedBlockingDeque.offer(70);

        System.out.println(
            "the peak element of the linkedBlockingDeque is(by peeking) "
            + linkedBlockingDeque.peek());

        System.out.println(
            "the peak element of the linkedBlockingDeque is(by polling) "
            + linkedBlockingDeque.poll());

        System.out.println(
            "the remaining capacity is "
            + linkedBlockingDeque.remainingCapacity());

        System.out.println(
            "element 30 removed "
            + linkedBlockingDeque.remove(30));

        System.out.println(
            "the linkedBlockingDeque contains 40 :"
            + linkedBlockingDeque.contains(40));

        System.out.println(
            "the linkedBlockingDeque contains 10 :"
            + linkedBlockingDeque.contains(10));

        System.out.println(
            "the size of the linkedBlockingDeque is "
            + linkedBlockingDeque.size());

        System.out.println(linkedBlockingDeque);
    }
}

Output

the elements of the linkedBlockingDeque is 
10    20    30    
the peak element of the linkedBlockingDeque is(by peeking) 10
the peak element of the linkedBlockingDeque is(by polling) 10
the remaining capacity is 2147483643
element 30 removed true
the linkedBlockingDeque contains 40 :false
the linkedBlockingDeque contains 10 :false
the size of the linkedBlockingDeque is 3
[20, 60, 70]