LinkedBlockingDeque en Java con ejemplos

La clase LinkedBlockingDeque en Java es parte de Java Collection Framework . Fue introducido en JDK 1.6 y pertenece al paquete java.util.concurrent . Es un Deque (cola de doble terminación) que bloquea un subproceso si ese subproceso intenta quitarle elementos mientras el Deque está vacío. Implementa BlockingDeque y proporciona una funcionalidad limitada opcionalmente basada en Nodes vinculados. Esta delimitación opcional se cumple al pasar el tamaño requerido en el constructor y ayuda a prevenir el desperdicio de memoria. Cuando no se especifica, la capacidad se toma por defecto como Integer.MAX_VALUE. Esta clase y su iterador implementan todos los métodos opcionales de la Colección yInterfaces de iterador . La implementación proporcionada por LinkedBlockingDeque es segura para subprocesos . Todos los métodos de cola en la clase logran sus efectos atómicamente usando ReentrantLock internamente.

La jerarquía de LinkedBlockingDeque

Implementa interfaces Serializable , Iterable<E> , Collection<E> , BlockingDeque<E> , BlockingQueue<E> , Deque<E> , Queue<E> y extiende las clases AbstractQueue<E> y AbstractCollection<E> .
Declaración:  

clase pública LinkedBlockingDeque<E> extiende AbstractQueue<E> implementa BlockingDeque<E>, Serializable 
 

Aquí, E es el tipo de elementos almacenados en la colección.

Constructores en Java LinkedBlockingDeque

Para crear una instancia de LinkedBlockingDeque, debemos importarla desde el paquete java.util.concurrent .

1. LinkedBlockingDeque() : este constructor se usa para construir un deque vacío. En este caso, la capacidad se establece en Integer.MAX_VALUE.

LinkedBlockingDeque<E> lbd = new LinkedBlockingDeque<E>();

2. LinkedBlockingDeque (capacidad int) : este constructor crea un LinkedBlockingDeque con la capacidad (fija) dada.

LinkedBlockingDeque<E> lbd = new LinkedBlockingDeque​<E>(int capacidad);

3. LinkedBlockingDeque(Collection<E> c) : este constructor se utiliza para construir una deque con los elementos de la colección pasados ​​como parámetro.

LinkedBlockingDeque​<E> lbd = new LinkedBlockingDeque​<E>(Colección<? extiende E> c);

A continuación se muestra un programa de ejemplo para ilustrar LinkedBlockingDeque en Java: 
 
Ejemplo 1:

// Java Program Demonstrate LinkedBlockingDeque
 
import java.util.concurrent.LinkedBlockingDeque;
import java.util.*;
 
public class LinkedBlockingDequeDemo {
    public static void main(String[] args)
        throws InterruptedException
    {
 
        // create object of LinkedBlockingDeque
        // using LinkedBlockingDeque() constructor
        LinkedBlockingDeque<Integer> LBD
            = new LinkedBlockingDeque<Integer>();
 
        // Add numbers to end of LinkedBlockingDeque
        LBD.add(7855642);
        LBD.add(35658786);
        LBD.add(5278367);
        LBD.add(74381793);
 
        // print Dequee
        System.out.println("Linked Blocking Deque1: "
                           + LBD);
        System.out.println("Size of Linked Blocking Deque1: "
                           + LBD.size());
 
        // create object of LinkedBlockingDeque
        // using LinkedBlockingDeque(int capacity) constructor
        LinkedBlockingDeque<Integer> LBD1
            = new LinkedBlockingDeque<Integer>(3);
 
        // Add numbers to end of LinkedBlockingDeque
        LBD1.add(7855642);
        LBD1.add(35658786);
        LBD1.add(5278367);
 
        try {
            // adding the 4th element
            // will throw exception for Deque full
            LBD1.add(74381793);
        }
        catch (Exception e) {
            System.out.println("Exception: " + e);
        }
 
        // print Dequee
        System.out.println("Linked Blocking Deque2: "
                           + LBD1);
        System.out.println("Size of Linked Blocking Deque2: "
                           + LBD1.size());
 
        // create object of LinkedBlockingDeque
        // using LinkedBlockingDeque(Collection c) constructor
        LinkedBlockingDeque<Integer> LBD2
            = new LinkedBlockingDeque<Integer>(LBD1);
 
        // print Dequee
        System.out.println("Linked Blocking Deque3: "
                           + LBD2);
    }
}

Linked Blocking Deque1: [7855642, 35658786, 5278367, 74381793]
Size of Linked Blocking Deque1: 4
Exception: java.lang.IllegalStateException: Deque full
Linked Blocking Deque2: [7855642, 35658786, 5278367]
Size of Linked Blocking Deque2: 3
Linked Blocking Deque3: [7855642, 35658786, 5278367]

Ejemplo 2: 
 

// Java code to illustrate methods of LinkedBlockingDeque
 
import java.util.concurrent.LinkedBlockingDeque;
import java.util.*;
 
public class LinkedBlockingDequeDemo {
    public static void main(String[] args)
        throws InterruptedException
    {
 
        // create object of LinkedBlockingDeque
        LinkedBlockingDeque<Integer> LBD
            = new LinkedBlockingDeque<Integer>();
 
        // Add numbers to end of LinkedBlockingDeque
        // using add() method
        LBD.add(7855642);
        LBD.add(35658786);
        LBD.add(5278367);
        LBD.add(74381793);
 
        // prints the Deque
        System.out.println("Linked Blocking Deque: "
                           + LBD);
 
        // prints the size of Deque after removal
        // using size() method
        System.out.println("Size of Linked Blocking Deque: "
                           + LBD.size());
 
        // removes the front element and prints it
        // using removeFirst() method
        System.out.println("First element: "
                           + LBD.removeFirst());
 
        // prints the Deque
        System.out.println("Linked Blocking Deque: "
                           + LBD);
 
        // prints the size of Deque after removal
        // using size() method
        System.out.println("Size of Linked Blocking Deque: "
                           + LBD.size());
 
        // Add numbers to end of LinkedBlockingDeque
        // using offer() method
        LBD.offer(20);
 
        // prints the Deque
        System.out.println("Linked Blocking Deque: "
                           + LBD);
 
        // prints the size of Deque after removal
        // using size() method
        System.out.println("Size of Linked Blocking Deque: "
                           + LBD.size());
    }
}

Linked Blocking Deque: [7855642, 35658786, 5278367, 74381793]
Size of Linked Blocking Deque: 4
First element: 7855642
Linked Blocking Deque: [35658786, 5278367, 74381793]
Size of Linked Blocking Deque: 3
Linked Blocking Deque: [35658786, 5278367, 74381793, 20]
Size of Linked Blocking Deque: 4

Operaciones básicas

1. Agregar elementos

LinkedBlockingDeque proporciona varios métodos para agregar o insertar elementos en ambos extremos. Son add(E e) , addAll(Collection c) , addFirst(E e) , addLast(E e) etc.

// Java Program Demonstrate adding
// elements to LinkedBlockingDeque
 
import java.util.concurrent.LinkedBlockingDeque;
import java.util.*;
 
public class AddingElementsExample {
    public static void main(String[] args)
        throws IllegalStateException
    {
 
        // create object of LinkedBlockingDeque
        LinkedBlockingDeque<Integer> lbd
            = new LinkedBlockingDeque<Integer>();
 
        // Add number to end of LinkedBlockingDeque
        lbd.add(7855642);
 
        // Add integer at the head or front
        lbd.addFirst(35658786);
 
        // Add integer at the tail or end
        lbd.addLast(5278367);
 
        // print Deque
        System.out.println("Linked Blocking Deque: " + lbd);
           
          // Create object of ArrayList collection
        ArrayList<Integer> ArrLis
            = new ArrayList<Integer>();
   
        // Add number to ArrayList
        ArrLis.add(55);
        ArrLis.add(66);
        ArrLis.add(77);
        ArrLis.add(88);
   
        // Print ArrayList
        System.out.println("ArrayList: " + ArrLis);
   
        // Function addAll() adds all the elements of
        // ArrayList to Deque
        lbd.addAll(ArrLis);
   
        // Print deque
        System.out.println("Linked Blocking Deque: " + lbd);
    }
}

Linked Blocking Deque: [35658786, 7855642, 5278367]
ArrayList: [55, 66, 77, 88]
Linked Blocking Deque: [35658786, 7855642, 5278367, 55, 66, 77, 88]

2. Eliminación de elementos

Existen varios métodos proporcionados por LinkedBlockingDeque para eliminar o eliminar elementos de cualquier extremo. Son remove() , removeFirst() , removeLast() etc.

// Java Program Demonstrate removing
// elements of LinkedBlockingDeque
 
import java.util.concurrent.LinkedBlockingDeque;
import java.util.*;
 
public class RemovingElementsExample {
    public static void main(String[] args)
        throws InterruptedException
    {
 
        // create object of LinkedBlockingDeque
        LinkedBlockingDeque<Integer> lbd
            = new LinkedBlockingDeque<Integer>();
 
        // Add numbers to end of LinkedBlockingDeque
        lbd.add(7855642);
        lbd.add(35658786);
        lbd.add(5278367);
        lbd.add(74381793);
        lbd.add(12345566);
 
        // print Dequeue
        System.out.println("Linked Blocking Deque: " + lbd);
 
        // removes the front element
        lbd.remove();
 
        // print the modified deque
        System.out.println("Linked Blocking Deque: " + lbd);
 
        // removes the front element
        lbd.removeFirst();
 
        // print the modified deque
        System.out.println("Linked Blocking Deque: " + lbd);
 
        // removes the last element
        lbd.removeLast();
 
        // print the modified deque
        System.out.println("Linked Blocking Deque: " + lbd);
    }
}

Linked Blocking Deque: [7855642, 35658786, 5278367, 74381793, 12345566]
Linked Blocking Deque: [35658786, 5278367, 74381793, 12345566]
Linked Blocking Deque: [5278367, 74381793, 12345566]
Linked Blocking Deque: [5278367, 74381793]

3. Iterando

El método iterator() de LinkedBlockingDeque devuelve un iterador sobre los elementos de esta deque en una secuencia adecuada. Los elementos se devolverán en orden desde el primero (cabeza) hasta el último (cola). El iterador devuelto es un iterador «débilmente coherente».

// Java Program Demonstrate iterating
// over LinkedBlockingDeque
 
import java.util.concurrent.LinkedBlockingDeque;
import java.util.*;
 
public class IteratingExample {
    public static void main(String[] args)
 
    {
 
        // create object of LinkedBlockingDeque
        LinkedBlockingDeque<Integer> LBD
            = new LinkedBlockingDeque<Integer>();
 
        // Add numbers to front of LinkedBlockingDeque
        LBD.addFirst(7855642);
        LBD.addFirst(35658786);
        LBD.addFirst(5278367);
        LBD.addFirst(74381793);
 
        // Call iterator() method of LinkedBlockingDeque
        Iterator iteratorVals = LBD.iterator();
 
        // Print elements of iterator
        // created from PriorityBlockingQueue
        System.out.println("The iterator values"
            + " of LinkedBlockingDeque are:");
 
        // prints the elements using an iterator
        while (iteratorVals.hasNext()) {
            System.out.println(iteratorVals.next());
        }
    }
}

The iterator values of LinkedBlockingDeque are:
74381793
5278367
35658786
7855642

Métodos de LinkedBlockingDeque

Métodos declarados en la clase java.util.AbstractCollection

Métodos declarados en la interfaz java.util.concurrent.BlockingDeque

Métodos declarados en la interfaz java.util.Collection

Métodos declarados en la interfaz java.util.Deque

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