Java ArrayBlockingQueue

En este tutorial, aprenderemos la clase ArrayBlockingQueue y sus métodos mediante ejemplos.

La clase ArrayBlockingQueue del framework Java Collections proporciona una implementación de cola de bloqueo de array utilizando un array.

ImplementaJava BlockingQueue接口.

Crear ArrayBlockingQueue

Para crear una cola de bloqueo de array, debemos importar el paquete java.util.concurrent.ArrayBlockingQueue.

Después de importar el paquete, se puede usar el siguiente método para crear una cola de bloqueo de array en Java:

ArrayBlockingQueue<Type> animal = new ArrayBlockingQueue<>(int capacidad);

Aquí,

• Type - Tipo de cola de bloqueo de array

• capacidad - Tamaño de la cola de bloqueo de array

Por ejemplo,

//Crear un ArrayBlockingQueue de tamaño5ArrayBlockingQueue de tipo cadena
ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>();5);
//Crear un ArrayBlockingQueue de tamaño5ArrayBlockingQueue de tipo entero
ArrayBlockingQueue<Integer> age = new ArrayBlockingQueue<>(5);

Nota:Debe proporcionar el tamaño del array.

Métodos de ArrayBlockingQueue

La clase ArrayBlockingQueue proporciona la implementación de todos los métodos del interfaz BlockingQueue.

Además, aprenderemos dos métodos put() y take(), que soportan operaciones de bloqueo en la cola de bloqueo de array.

Estas dos métodos distinguen la cola de bloqueo de array de otras colas típicas.

Insertar elemento

• add() - Inserta el elemento especificado en la cola de bloqueo de array. Si la cola está llena, lanzará una excepción.

• offer() - Inserta el elemento especificado en la cola de bloqueo de array. Si la cola está llena, devuelve false.

Por ejemplo,

import java.util.concurrent.ArrayBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>();5);
　　　　　　　　//Usando add()
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　//Usando offer()
　　　　　　　　animals.offer("Horse");
　　　　　　　　System.out.println("ArrayBlockingQueue: ");　+　animals);
　　　　}
}

Resultados de salida

ArrayBlockingQueue: [Dog, Cat, Horse]

Acceder al elemento

• peek() - Devuelve un elemento desde el frente de la cola de bloqueo de array. Si la cola está vacía, devuelve null.

• iterator() - Devuelve un objeto de iterador que permite acceder a los elementos de la cola de bloqueo de array en orden. Si la cola está vacía, lanza una excepción. Debemos importar el paquete java.util.Iterator para poder usarlo.

Por ejemplo,

import java.util.concurrent.ArrayBlockingQueue;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>();5);
　　　　　　　　//Agregar elemento
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("ArrayBlockingQueue: ");　+　animals);
　　　　　　　　//　Usando peek()
　　　　　　　　String elemento = animals.peek();
　　　　　　　　System.out.println("Acceder al elemento: ")　+　element);
　　　　　　　　//　Usando iterator()
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　System.out.print("Elementos del ArrayBlockingQueue: ");
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Resultados de salida

ArrayBlockingQueue: [Dog, Cat, Horse]
Acceder al elemento: Dog
Elementos del ArrayBlockingQueue: Dog, Cat, Horse,

Eliminar elemento

• remove() - Devuelve y elimina el elemento especificado de la cola de bloqueo de array. Si la cola está vacía, lanza una excepción.

• poll() - Devuelve y elimina el elemento especificado de la cola de bloqueo de array. Si la cola está vacía, devuelve null.

• clear() - Eliminar todos los elementos de la cola de bloqueo de array.

Por ejemplo,

import java.util.concurrent.ArrayBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>();5);
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("ArrayBlockingQueue: ");　+　animals);
　　　　　　　　//　Usando remove()
　　　　　　　　String elemento1　= animals.remove();
　　　　　　　　System.out.println("Eliminar elemento: ")
　　　　　　　　System.out.println("Usando remove(): " + "")　+　elemento1);
　　　　　　　　//　Usando poll()
　　　　　　　　String elemento2　= animals.poll();
　　　　　　　　System.out.println("Usando poll(): " + "")　+　elemento2);
　　　　　　　　//　Usando clear()
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("El ArrayBlockingQueue actualizado: " + "")　+　animals);
　　　　}
}

Resultados de salida

ArrayBlockingQueue: [Dog, Cat, Horse]
Eliminar elemento:
Usando remove(): Dog
Usando poll(): Cat
ArrayBlockingQueue actualizado: []

Métodos put() y take()

En el proceso de múltiples hilos, podemos usar put() y take() para bloquear la operación de un hilo, haciendo que se sincronice con otro hilo. Estos métodos esperarán hasta que puedan ejecutarse con éxito.

Método put()

Para agregar un elemento al final de la cola de bloqueo de array, se puede usar el método put().

Si la cola de bloqueo de array está llena, esperará hasta que haya suficiente espacio en la cola de bloqueo de array para agregar elementos.

Por ejemplo,

import java.util.concurrent.ArrayBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>();5);
　　　　　　　try {
　　　　　　　　　　　//Agregar elementos a animals
　　　　　　　　　　　animals.put("Dog");
　　　　　　　　　　　animals.put("Cat");
　　　　　　　　　　　System.out.println("ArrayBlockingQueue: ");　+　animals);
　　　　　　　　}
　　　　　　　　catch(Exception e) {
　　　　　　　　　　　　System.out.println(e);
　　　　　　　　}
　　　　}
}

Resultados de salida

ArrayBlockingQueue: [Dog, Cat]

Aquí, si el método put() se interrumpe durante la espera, puede lanzar la excepción InterruptedException. Por lo tanto, debemos incluirlo en un bloque try..catch.

Método take()

Para devolver y eliminar un elemento desde el frente de la cola de bloqueo de array, podemos usar el método take().

Si la cola de bloqueo de array está vacía, esperará hasta que haya un elemento que eliminar en la cola de bloqueo de array.

Por ejemplo,

import java.util.concurrent.ArrayBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>();5);
　　　　　　　try {
　　　　　　　　　　　//Agregar elementos a animals
　　　　　　　　　　　animals.put("Dog");
　　　　　　　　　　　animals.put("Cat");
　　　　　　　　　　　System.out.println("ArrayBlockingQueue: ");　+　animals);
　　　　　　　　　　　//Eliminar un elemento
　　　　　　　　　　　String element = animals.take();
　　　　　　　　　　　System.out.println("Elemento eliminado: ");　+　element);
　　　　　　　　}
　　　　　　　　catch(Exception e) {
　　　　　　　　　　　　System.out.println(e);
　　　　　　　　}
　　　　}
}

Resultados de salida

ArrayBlockingQueue: [Dog, Cat]
Elemento eliminado: Dog

Aquí, si el método take() se interrumpe durante el proceso de espera, lanzará la excepción InterruptedException. Por lo tanto, debemos encapsularlo en un bloque try...catch.

Otros métodos

¿Por qué usar ArrayBlockingQueue?

ArrayBlockingQueue utiliza un array como su almacenamiento interno.

Se considera que线程安全的conjuntos. Por lo tanto, se utiliza comúnmente en aplicaciones de múltiples hilos.

Supongamos que un hilo está insertando elementos en la cola y otro hilo está eliminando elementos de la cola.

Ahora, si el primer hilo es más lento que el segundo hilo, la cola de bloqueo de array permite que el segundo hilo espere hasta que el primer hilo complete su operación.