Clase LinkedBlockingQueue en Java

LinkedBlockingQueue es una cola de bloqueo limitada opcionalmente basada en Nodes vinculados. Significa que LinkedBlockingQueue puede limitarse, si se proporciona su capacidad, de lo contrario, LinkedBlockingQueue no estará delimitado. La capacidad se puede dar como parámetro al constructor de LinkedBlockingQueue. Esta cola ordena elementos FIFO (first-in-first-out). Significa que la cabeza de esta cola es el elemento más antiguo de los elementos presentes en esta cola. La cola de esta cola es el elemento más nuevo de los elementos de esta cola. Los elementos recién insertados siempre se insertan al final de la cola y las operaciones de recuperación de la cola obtienen elementos al principio de la cola. Las colas vinculadas suelen tener un mayor rendimiento que las colas basadas en arrays, pero un rendimiento menos predecible en la mayoría de las aplicaciones simultáneas.

La capacidad, si no se especifica, es igual a Integer.MAX_VALUE . Los Nodes vinculados se crean dinámicamente en cada inserción, hasta que no se llena la capacidad de la cola. Esta clase y su iterador implementan todos los métodos opcionales de las interfaces Collection e Iterator. Es miembro de Java Collections Framework.
 

La jerarquía de LinkedBlockingQueue
 

LinkedBlockingQueue<E> extiende AbstractQueue<E> e implementa las interfaces Serializable , Iterable<E> , Collection<E> , BlockingQueue<E> , Queue<E> .

Declaración: 

clase pública LinkedBlockingQueue<E> extiende AbstractQueue<E> implementa BlockingQueue<E>, Serializable
 

E – tipo de elementos contenidos en esta colección.

Constructores de LinkedBlockingQueue:

Para construir una LinkedBlockingQueue, debemos importarla desde java.util.concurrent.LinkedBlockingQueue . Aquí, la capacidad es el tamaño de la cola de bloqueo vinculada.

1. LinkedBlockingQueue() : crea una LinkedBlockingQueue con una capacidad de Integer.MAX_VALUE.

LinkedBlockingQueue<E> lbq = new LinkedBlockingQueue<E>();

Ejemplo:

// Java program to demonstrate
// LinkedBlockingQueue() constructor
  
import java.util.concurrent.LinkedBlockingQueue;
  
public class LinkedBlockingQueueDemo {
  
    public static void main(String[] args)
    {
  
        // create object of LinkedBlockingQueue
        // using LinkedBlockingQueue() constructor
        LinkedBlockingQueue<Integer> lbq
            = new LinkedBlockingQueue<Integer>();
  
        // add  numbers
        lbq.add(1);
        lbq.add(2);
        lbq.add(3);
        lbq.add(4);
        lbq.add(5);
  
        // print queue
        System.out.println("LinkedBlockingQueue:" + lbq);
    }
}

LinkedBlockingQueue:[1, 2, 3, 4, 5]

2. LinkedBlockingQueue (capacidad int) : crea un LinkedBlockingQueue con la capacidad (fija) dada.

LinkedBlockingQueue<E> lbq = new LinkedBlockingQueue​(capacidad int);

Ejemplo:

// Java program to demonstrate
// LinkedBlockingQueue(int initialCapacity) constructor
  
import java.util.concurrent.LinkedBlockingQueue;
  
public class GFG {
  
    public static void main(String[] args)
    {
        // define capacity of LinkedBlockingQueue
        int capacity = 15;
  
        // create object of LinkedBlockingQueue
        // using LinkedBlockingQueue(int initialCapacity)
        // constructor
        LinkedBlockingQueue<Integer> lbq
            = new LinkedBlockingQueue<Integer>(capacity);
  
        // add  numbers
        lbq.add(1);
        lbq.add(2);
        lbq.add(3);
  
        // print queue
        System.out.println("LinkedBlockingQueue:" + lbq);
    }
}

LinkedBlockingQueue:[1, 2, 3]

3. LinkedBlockingQueue​(Collection<? extends E> c) : crea una LinkedBlockingQueue con una capacidad de Integer.MAX_VALUE, que inicialmente contiene los elementos de la colección dada, agregados en orden transversal del iterador de la colección.

LinkedBlockingQueue<E> lbq = new LinkedBlockingQueue​(Colección<? extiende E> c);

Ejemplo:

// Java program to demonstrate
// LinkedBlockingQueue(Collection c) constructor
  
import java.util.concurrent.LinkedBlockingQueue;
import java.util.*;
  
public class GFG {
  
    public static void main(String[] args)
    {
  
        // Creating a Collection
        Vector<Integer> v = new Vector<Integer>();
        v.addElement(1);
        v.addElement(2);
        v.addElement(3);
        v.addElement(4);
        v.addElement(5);
  
        // create object of LinkedBlockingQueue
        // using LinkedBlockingQueue(Collection c)
        // constructor
        LinkedBlockingQueue<Integer> lbq
            = new LinkedBlockingQueue<Integer>(v);
  
        // print queue
        System.out.println("LinkedBlockingQueue:" + lbq);
    }
}

LinkedBlockingQueue:[1, 2, 3, 4, 5]

Operaciones básicas

1. Agregar elementos

El método add(E e) de LinkedBlockingQueue inserta el elemento pasado como parámetro al método al final de esta LinkedBlockingQueue, si la cola no está llena. Si la cola está llena, este método esperará a que haya espacio disponible y, una vez que haya espacio disponible, insertará el elemento en LinkedBlockingQueue.

// Java Program to Demonstrate adding 
// elements to the LinkedBlockingQueue
  
import java.util.concurrent.LinkedBlockingQueue;
  
public class AddingElementsExample {
  
    public static void main(String[] args)
    {
        // define capacity of LinkedBlockingQueue
        int capacity = 15;
  
        // create object of LinkedBlockingQueue
        LinkedBlockingQueue<Integer> lbq
            = new LinkedBlockingQueue<Integer>(capacity);
  
        // add  numbers
        lbq.add(1);
        lbq.add(2);
        lbq.add(3);
  
        // print queue
        System.out.println("LinkedBlockingQueue:" + lbq);
    }
}

LinkedBlockingQueue:[1, 2, 3]

2. Eliminación de elementos

El método remove(Object obj) de LinkedBlockingQueue elimina solo una instancia del Objeto dado, pasado como parámetro, de esta LinkedBlockingQueue si está presente. Elimina un elemento e tal que obj.equals(e) y si esta cola contiene una o más instancias del elemento e. Este método devuelve verdadero si esta cola contenía el elemento que ahora se elimina de LinkedBlockingQueue.
 

// Java Program to Demonstrate removing 
// elements from the LinkedBlockingQueue
  
import java.util.concurrent.LinkedBlockingQueue;
  
public class RemovingElementsExample {
  
    public static void main(String[] args)
    {
        // define capacity of LinkedBlockingQueue
        int capacity = 15;
  
        // create object of LinkedBlockingQueue
        LinkedBlockingQueue<Integer> lbq
            = new LinkedBlockingQueue<Integer>(capacity);
  
        // add  numbers
        lbq.add(1);
        lbq.add(2);
        lbq.add(3);
  
        // print queue
        System.out.println("LinkedBlockingQueue:" + lbq);
  
        // remove all the elements
        lbq.clear();
  
        // print queue
        System.out.println("LinkedBlockingQueue:" + lbq);
    }
}

LinkedBlockingQueue:[1, 2, 3]
LinkedBlockingQueue:[]

3. Iterando 

El método iterator () de LinkedBlockingQueue devuelve un iterador de los mismos elementos, como este LinkedBlockingQueue, en una secuencia adecuada. Los elementos devueltos por este método contienen todos los elementos en orden desde el primero (cabeza) hasta el último (cola) de LinkedBlockingQueue. El iterador devuelto es débilmente coherente.

// Java Program Demonstrate iterating
// over LinkedBlockingQueue 
  
import java.util.concurrent.LinkedBlockingQueue; 
import java.util.Iterator; 
  
public class IteratingExample { 
  
    public static void main(String[] args) 
    { 
        // define capacity of LinkedBlockingQueue 
        int capacityOfQueue = 7; 
  
        // create object of LinkedBlockingQueue 
        LinkedBlockingQueue<String> linkedQueue 
            = new LinkedBlockingQueue<String>(capacityOfQueue); 
  
        // Add element to LinkedBlockingQueue 
        linkedQueue.add("John"); 
        linkedQueue.add("Tom"); 
        linkedQueue.add("Clark"); 
        linkedQueue.add("Kat"); 
  
        // create Iterator of linkedQueue using iterator() method 
        Iterator<String> listOfNames = linkedQueue.iterator(); 
  
        // print result 
        System.out.println("list of names:"); 
        while (listOfNames.hasNext()) 
            System.out.println(listOfNames.next()); 
    } 
} 

list of names:
John
Tom
Clark
Kat

4. Elementos de acceso

El método peek() de LinkedBlockingQueue devuelve el encabezado de LinkedBlockingQueue. Recupera el valor del encabezado de LinkedBlockingQueue pero no lo elimina. Si LinkedBlockingQueue está vacío, este método devuelve un valor nulo.

// Java Program Demonstrate accessing
// elements of LinkedBlockingQueue 
  
import java.util.concurrent.LinkedBlockingQueue; 
public class AccessingElementsExample { 
  
    public static void main(String[] args) 
    { 
        // define capacity of LinkedBlockingQueue 
        int capacityOfQueue = 7; 
  
        // create object of LinkedBlockingQueue 
        LinkedBlockingQueue<String> linkedQueue 
            = new LinkedBlockingQueue<String>(capacityOfQueue); 
  
        // Add element to LinkedBlockingQueue 
        linkedQueue.add("John"); 
        linkedQueue.add("Tom"); 
        linkedQueue.add("Clark"); 
        linkedQueue.add("Kat"); 
  
        // find head of linkedQueue using peek() method 
        String head = linkedQueue.peek(); 
  
        // print result 
        System.out.println("Queue is " + linkedQueue); 
  
        // print head of queue 
        System.out.println("Head of Queue is " + head); 
  
        // removing one element 
        linkedQueue.remove(); 
  
        // again get head of queue 
        head = linkedQueue.peek(); 
  
        // print result 
        System.out.println("\nRemoving one element from Queue\n"); 
        System.out.println("Queue is " + linkedQueue); 
  
        // print head of queue 
        System.out.println("Head of Queue is " + head); 
    } 
} 

Queue is [John, Tom, Clark, Kat]
Head of Queue is John

Removing one element from Queue

Queue is [Tom, Clark, Kat]
Head of Queue is Tom

Métodos de LinkedBlockingQueue

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

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

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.Queue

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