Java LinkedBlockingQueue
Java LinkedBlockingQueue
En este tutorial, aprenderemos sobre la clase LinkedBLockingQueue y sus métodos con la ayuda de ejemplos.
El LinkedBlockingQueue clase de Java Collections framework proporciona la implementación de la cola de bloqueo usando una lista enlazada.
Implementa la interfaz Java BlockingQueue.
Creación de LinkedBlockingQueue
Para crear una cola de bloqueo vinculada, debemos importar el java.util.concurrent.LinkedBlockingQueue paquete.
Así es como podemos crear una cola de bloqueo vinculada en Java:
LinkedBlockingQueue<Type> animal = new LinkedBlockingQueue<>();
Aquí la capacidad inicial por defecto será 2 31 -1.
LinkedBlockingQueue<Type> animal = new LinkedBlockingQueue<>(int capacity);
Aquí,
- Tipo - el tipo de la cola de bloqueo vinculada
- capacidad - el tamaño de la cola de bloqueo vinculada
Por ejemplo,
// Creating String type LinkedBlockingQueue with size 5
LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
// Creating Integer type LinkedBlockingQueue with size 5
LinkedBlockingQueue<Integer> age = new LinkedBlockingQueue<>(5);
Métodos de LinkedBlockingQueue
El LinkedBlockingQueue class proporciona la implementación de todos los métodos en la interfaz BlockingQueue.
Estos métodos se utilizan para insertar, acceder y eliminar elementos de las colas de bloqueo vinculadas.
Además, aprenderemos sobre dos métodos put() y take() que admiten la operación de bloqueo en la cola de bloqueo vinculada.
Estos dos métodos distinguen la cola de bloqueo vinculada de otras colas típicas.
Insertar elementos
add()- Inserta un elemento específico en la cola de bloqueo vinculada. Lanza una excepción si la cola está llena.offer()- Inserta un elemento específico en la cola de bloqueo vinculada. Devuelvefalsesi la cola está llena.
Por ejemplo,
import java.util.concurrent.LinkedBlockingQueue;
class Main {
public static void main(String[] args) {
LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
// Using add()
animals.add("Dog");
animals.add("Cat");
// Using offer()
animals.offer("Horse");
System.out.println("LinkedBlockingQueue: " + animals);
}
}
Salida
LinkedBlockingQueue: [Dog, Cat, Horse]
Elementos de acceso
peek()- Devuelve un elemento del frente de la cola de bloqueo vinculada. Devuelvenullsi la cola está vacía.iterator()- Devuelve un objeto iterador para acceder secuencialmente a un elemento de la cola de bloqueo vinculada. Lanza una excepción si la cola está vacía. Debemos importar eljava.util.Iteratorpaquete para usarlo.
Por ejemplo,
import java.util.concurrent.LinkedBlockingQueue;
import java.util.Iterator;
class Main {
public static void main(String[] args) {
LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
// Add elements
animals.add("Dog");
animals.add("Cat");
animals.add("Horse");
System.out.println("LinkedBlockingQueue: " + animals);
// Using peek()
String element = animals.peek();
System.out.println("Accessed Element: " + element);
// Using iterator()
Iterator<String> iterate = animals.iterator();
System.out.print("LinkedBlockingQueue Elements: ");
while(iterate.hasNext()) {
System.out.print(iterate.next());
System.out.print(", ");
}
}
}
Salida
LinkedBlockingQueue: [Dog, Cat, Horse] Accessed Element: Dog LinkedBlockingQueue Elements: Dog, Cat, Horse,
Eliminar elementos
remove()- Devuelve y elimina un elemento específico de la cola de bloqueo vinculada. Lanza una excepción si la cola está vacía.poll()- Devuelve y elimina un elemento específico de la cola de bloqueo vinculada. Devuelvenullsi la cola está vacía.clear()- Elimina todos los elementos de la cola de bloqueo vinculada.
Por ejemplo,
import java.util.concurrent.LinkedBlockingQueue;
class Main {
public static void main(String[] args) {
LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
animals.add("Dog");
animals.add("Cat");
animals.add("Horse");
System.out.println("LinkedBlockingQueue " + animals);
// Using remove()
String element1 = animals.remove();
System.out.println("Removed Element:");
System.out.println("Using remove(): " + element1);
// Using poll()
String element2 = animals.poll();
System.out.println("Using poll(): " + element2);
// Using clear()
animals.clear();
System.out.println("Updated LinkedBlockingQueue " + animals);
}
}
Salida
LinkedBlockingQueue: [Dog, Cat, Horse] Removed Elements: Using remove(): Dog Using poll(): Cat Updated LinkedBlockingQueue: []
Métodos put() y take()
En procesos de subprocesos múltiples, podemos usar put() y take() para bloquear el funcionamiento de un subproceso para sincronizarlo con otro subproceso. Estos métodos esperarán hasta que puedan ejecutarse con éxito.
Método put()
Para insertar el elemento especificado al final de una cola de bloqueo vinculada, usamos el put() método.
Si la cola de bloqueo vinculada está llena, espera hasta que haya espacio en la cola de bloqueo vinculada para insertar el elemento.
Por ejemplo,
import java.util.concurrent.LinkedBlockingQueue;
class Main {
public static void main(String[] args) {
LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
try {
// Add elements to animals
animals.put("Dog");
animals.put("Cat");
System.out.println("LinkedBlockingQueue: " + animals);
}
catch(Exception e) {
System.out.println(e);
}
}
}
Salida
LinkedBlockingQueue: [Dog, Cat]
Aquí, el put() el método puede arrojar un InterruptedException si se interrumpe durante la espera. Por lo tanto, debemos encerrarlo dentro de un bloque try..catch.
Método tomar()
Para devolver y eliminar un elemento del frente de la cola de bloqueo vinculada, podemos usar el take() método.
Si la cola de bloqueo vinculada está vacía, espera hasta que haya elementos en la cola de bloqueo vinculada para ser eliminados.
Por ejemplo,
import java.util.concurrent.LinkedBlockingQueue;
class Main {
public static void main(String[] args) {
LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
try {
//Add elements to animals
animals.put("Dog");
animals.put("Cat");
System.out.println("LinkedBlockingQueue: " + animals);
// Remove an element
String element = animals.take();
System.out.println("Removed Element: " + element);
System.out.println("New LinkedBlockingQueue: " + animals);
}
catch(Exception e) {
System.out.println(e);
}
}
}
Salida
LinkedBlockingQueue: [Dog, Cat] Removed Element: Dog New LinkedBlockingQueue: [Cat]
Aquí, el take() arrojará un InterrupedException si se interrumpe durante la espera. Por lo tanto, debemos encerrarlo dentro de un try...catch bloquear.
Otros métodos
| Métodos | Descripciones |
|---|---|
contains(element) | Busca en la cola de bloqueo vinculada el elemento especificado. Si se encuentra el elemento, devuelve true , si no, devuelve false . |
size() | Devuelve la longitud de la cola de bloqueo vinculada. |
toArray() | Convierte la cola de bloqueo vinculada en una matriz y devuelve la matriz. |
toString() | Convierte la cola de bloqueo vinculada a cadena |
¿Por qué usar LinkedBlockingQueue?
El LinkedBlockingQueue utiliza listas enlazadas como almacenamiento interno.
Se considera como seguro para subprocesos recopilación. Por lo tanto, generalmente se usa en aplicaciones de subprocesos múltiples.
Supongamos que un subproceso está insertando elementos en la cola y otro subproceso está eliminando elementos de la cola.
Ahora, si el primer subproceso es más lento que el segundo, entonces la cola de bloqueo vinculada puede hacer que el segundo subproceso espere hasta que el primer subproceso complete sus operaciones.
Java