BlockingDeque en Java

La interfaz BlockingDeque es una parte de Java Collections Framework. Recibe su nombre porque bloquea operaciones ilegales como la inserción en una cola llena o la eliminación de una cola vacía, todas estas propiedades están integradas en la estructura de esta interfaz. Dado que es una deque (cola de dos extremos), las operaciones de inserción, eliminación y recorrido se pueden realizar desde ambos extremos. BlockingDeque es una interfaz, por lo que no podemos declarar ningún objeto con él.

Jerarquía

BlockingDeque se extiende desde la interfaz BlockingQueue, que a su vez se extiende desde la interfaz Queue y la interfaz Deque .

La Jerarquía de BlockingDeque

Nota : el marco Interfaces of the Collection puede tener clases de implementación adicionales e interfaces de extensión, pero la imagen de arriba solo muestra la jerarquía de BlockingDeque y sus clases de implementación.

Sintaxis:

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

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

Clases que implementan BlockingDeque

La clase de implementación de BlockingDeque es LinkedBlockingDeque . Esta clase es la implementación de BlockingDeque y la estructura de datos de lista enlazada . LinkedBlockingDeque se puede limitar opcionalmente mediante un constructor; sin embargo, si la capacidad no se especifica, es Integer.MAX_VALUE de forma predeterminada. Los Nodes se agregan dinámicamente en el momento de la inserción obedeciendo las restricciones de capacidad. Para usar BlockingDeque en su código, use esta declaración de importación.

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

La sintaxis para crear objetos:

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

Ejemplo: en el código que se proporciona a continuación, realizamos algunas operaciones básicas en LinkedBlockingDeque, como crear un objeto, agregar elementos, eliminar elementos y usar un iterador para atravesar LinkedBlockingDeque.

// Java Program for BlockingDeque
import java.util.concurrent.*;
import java.util.*;
  
public class BlockingDequeExample {
  
    public static void main(String[] args) {
          
        // Instantiate an object using LinkedBlockingDeque named lbdq
        BlockingDeque<Integer> lbdq = new LinkedBlockingDeque<Integer>();
  
        // Add elements using add()
        lbdq.add(134);
        lbdq.add(245);
        lbdq.add(23);
        lbdq.add(122);
        lbdq.add(90);
          
        // Create an iterator to traverse the deque
        Iterator<Integer> lbdqIter = lbdq.iterator();
          
        // Print the elements of lbdq on to the console
        System.out.println("The LinkedBlockingDeque lbdq contains:");
          
        for(int i = 0; i<lbdq.size(); i++)
        {
            System.out.print(lbdqIter.next() + " ");
        }
          
        // Remove 23 and display appropriate message if the
        // operation is successful
        if(lbdq.remove(23))
        {
            System.out.println("\n\nThe element 23 has been removed");
        }
        else
        {
            System.out.println("\n\nNo such element was found");
        }
          
        // Print the elements of lbdq without using iterator
        System.out.println("\nThe LinkedBlockingDeque lbdq"+
                       " after remove operation contains:");
        System.out.println(lbdq);
    }
  
}

Producción:

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]

Operaciones básicas

1. Agregar elementos

Los elementos se pueden agregar a un LinkedBlockedDeque de diferentes maneras según el tipo de estructura que intentemos usar. El método más común es el método add() mediante el cual podemos agregar elementos al final de la deque. También podemos usar el método addAll() (que es un método de la interfaz Collection) para agregar una colección completa a LinkedBlockingDeque. Si deseamos usar el deque como una cola, podemos usar add() y put().

// Java Program for Adding elements to a LinkedBlockingDeque
import java.util.concurrent.*;
  
public class AddingElements {
  
    public static void main(String[] args) {
          
        // Instantiate a LinkedBlockingDeque named lbdq1
        BlockingDeque<Integer> lbdq1 = new LinkedBlockingDeque<Integer>();
          
        // Add elements using add()
        lbdq1.add(145);
        lbdq1.add(89);
        lbdq1.add(65);
        lbdq1.add(122);
        lbdq1.add(11);
          
        // Print the contents of lbdq1 on the console
        System.out.println("Contents of lbdq1: " + lbdq1);
          
        // Instantiate a LinkedBlockingDeque named lbdq2
        LinkedBlockingDeque<Integer> lbdq2 = new LinkedBlockingDeque<Integer>();
          
        // Add elements from lbdq1 using addAll()
        lbdq2.addAll(lbdq1);
          
        // Print the contents of lbdq2 on the console
        System.out.println("\nContents of lbdq2: " + lbdq2);
          
    }
  
}

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

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

2. Elementos de acceso

Se puede acceder a los elementos de LinkedBlockingDeque usando contains(), element(), peek(), poll(). También hay variaciones de estos métodos que se dan en la tabla anterior junto con sus descripciones.

// Java Program for Accessing the elements of a LinkedBlockingDeque
  
import java.util.concurrent.*;
  
public class AccessingElements {
  
    public static void main(String[] args) {
          
        // Instantiate an object of LinkedBlockingDeque named lbdq
        BlockingDeque<Integer> lbdq = new LinkedBlockingDeque<Integer>();
  
        // Add elements using add()
        lbdq.add(22);
        lbdq.add(125);
        lbdq.add(723);
        lbdq.add(172);
        lbdq.add(100);
          
        // Print the elements of lbdq on the console
        System.out.println("The LinkedBlockingDeque, lbdq contains:");
        System.out.println(lbdq);
          
        // To check if the deque contains 22
        if(lbdq.contains(22))
            System.out.println("The LinkedBlockingDeque, lbdq contains 22");
        else
            System.out.println("No such element exists");
  
        // Using element() to retrieve the head of the deque
        int head = lbdq.element();
        System.out.println("The head of lbdq: " + head);
          
        // Using peekLast() to retrieve the tail of the deque
        int tail  = lbdq.peekLast();
        System.out.println("The tail of lbdq: " + tail);
          
    }
  
}

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. Eliminación de elementos

Los elementos se pueden eliminar de un LinkedBlockingDeque mediante remove(). Otros métodos como take() y poll() también se pueden usar para eliminar el primer y el último elemento.

// Java Program for removing elements from a LinkedBlockingDeque
  
import java.util.concurrent.*;
  
public class RemovingElements {
  
    public static void main(String[] args) {
          
        // Instantiate an object of LinkedBlockingDeque named lbdq
        BlockingDeque<Integer> lbdq = new LinkedBlockingDeque<Integer>();
          
        // Add elements using add()
        lbdq.add(75);
        lbdq.add(86);
        lbdq.add(13);
        lbdq.add(44);
        lbdq.add(10);
          
        // Print the elements of lbdq on the console
        System.out.println("The LinkedBlockingDeque, lbdq contains:");
        System.out.println(lbdq);
          
        // Remove elements using remove();
        lbdq.remove(86);
        lbdq.remove(44);
          
        // Trying to remove an element
        // that doesn't exist
        // in the LinkedBlockingDeque
        lbdq.remove(1);
          
        // Print the elements of lbdq on the console
        System.out.println("\nThe LinkedBlockingDeque, lbdq contains:");
        System.out.println(lbdq);
  
    }
  
}

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

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

4. Iterando a través de los Elementos

Para iterar a través de los elementos de un LinkedBlockingDeque, podemos crear un iterador y usar los métodos de la interfaz Iterable, que es la raíz de Collection Framework de Java, para acceder a los elementos. El método next() de Iterable devuelve el elemento de cualquier colección.

// Java Program to iterate through the LinkedBlockingDeque
import java.util.Iterator;
import java.util.concurrent.*;
  
public class IteratingThroughElements {
  
    public static void main(String[] args) {
          
        // Instantiate an object of LinkedBlockingDeque named lbdq
        BlockingDeque<Integer> lbdq = new LinkedBlockingDeque<Integer>();
          
        // Add elements using add()
        lbdq.add(166);
        lbdq.add(246);
        lbdq.add(66);
        lbdq.add(292);
        lbdq.add(98);
          
        // Create an iterator to traverse lbdq
        Iterator<Integer> lbdqIter = lbdq.iterator();
          
        // Print the elements of lbdq on to the console
        System.out.println("The LinkedBlockingDeque, lbdq contains:");
          
        for(int i = 0; i<lbdq.size(); i++)
        {
            System.out.print(lbdqIter.next() + " ");
        }        
    }
  
}

The LinkedBlockingDeque, lbdq contains:
166 246 66 292 98 

Métodos de BlockingDeque

La interfaz BlockingDeque tiene varios métodos que deben ser definidos por cada clase de implementación. Un deque se puede implementar como una cola y como una pila, por lo tanto, la interfaz BlockingDeque proporciona métodos para hacer lo mismo. La siguiente tabla proporciona una lista de todos los métodos y su función.

Aquí, 

• E – El tipo de elementos de la colección.
• TimeUnit : una enumeración que representa las duraciones de tiempo.

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

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

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

Métodos declarados en la interfaz java.lang.Iterable

El comportamiento de los métodos BlockingDeque

Los siguientes son los métodos proporcionados por BlockingDeque para las operaciones de inserción, eliminación y examen en el deque. Cada uno de los cuatro conjuntos de métodos se comporta de manera diferente si la operación solicitada no se cumple inmediatamente. 

• Lanza una excepción: se lanzará una excepción si la operación solicitada no se cumple de inmediato.
• Valor especial: se devuelve un valor especial si la operación no se cumple inmediatamente.
• Bloqueos: la llamada al método se bloquea si la operación intentada no se satisface inmediatamente y espera hasta que se ejecuta.
• Tiempos de espera: se devuelve un valor especial que indica si la operación tuvo éxito o no. Si la operación solicitada no es posible de inmediato, la llamada al método se bloquea hasta que lo es, pero no espera más que el tiempo de espera dado. 

Sabemos que podemos insertar, eliminar y examinar elementos desde ambas direcciones en BlockingDeque. Dado que BlockingDeque amplía BlockingQueue , los métodos para las operaciones de inserción, eliminación y examen que actúan en una dirección en BlockingDeque son similares a BlockingQueue. La siguiente comparación explica lo mismo.

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