Java ArrayBlockingQueue

En este tutorial, aprenderemos sobre la clase ArrayBlockingQueue y sus métodos con la ayuda de ejemplos.

El ArrayBlockingQueue La clase del marco de colecciones de Java proporciona la implementación de la cola de bloqueo mediante una matriz.

Implementa la interfaz Java BlockingQueue.

Creando ArrayBlockingQueue

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

Una vez que importamos el paquete, así es como podemos crear una cola de bloqueo de matrices en Java:

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

Aquí,

Tipo - el tipo de cola de bloqueo de matriz
capacidad - el tamaño de la cola de bloqueo de matriz

Por ejemplo,

// Creating String type ArrayBlockingQueue with size 5
ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

// Creating Integer type ArrayBlockingQueue with size 5
ArrayBlockingQueue<Integer> age = new ArrayBlockingQueue<>(5);

Nota: Es obligatorio proporcionar el tamaño de la matriz.

Métodos de ArrayBlockingQueue

El ArrayBlockingQueue class proporciona la implementación de todos los métodos en el BlockingQueue interfaz.

Estos métodos se utilizan para insertar, acceder y eliminar elementos de las colas de bloqueo de matrices.

Además, aprenderemos sobre dos métodos put() y take() que admiten la operación de bloqueo en la cola de bloqueo de matrices.

Estos dos métodos distinguen la cola de bloqueo de matriz de otras colas típicas.

Insertar elementos

add() - Inserta el elemento especificado en la cola de bloqueo de matriz. Lanza una excepción si la cola está llena.
offer() - Inserta el elemento especificado en la cola de bloqueo de matriz. Devuelve false si la cola está llena.

Por ejemplo,

import java.util.concurrent.ArrayBlockingQueue;

class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

        // Using add()
        animals.add("Dog");
        animals.add("Cat");

        // Using offer()
        animals.offer("Horse");
        System.out.println("ArrayBlockingQueue: " + animals);
    }
}

Salida

ArrayBlockingQueue: [Dog, Cat, Horse]

Elementos de acceso

peek() - Devuelve un elemento del frente de la cola de bloqueo de matriz. Devuelve null si la cola está vacía.
iterator() - Devuelve un objeto iterador para acceder secuencialmente a elementos de la cola de bloqueo de matriz. Lanza una excepción si la cola está vacía. Debemos importar el java.util.Iterator paquete para 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);

        // Add elements
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("ArrayBlockingQueue: " + animals);

        // Using peek()
        String element = animals.peek();
        System.out.println("Accessed Element: " + element);

        // Using iterator()
        Iterator<String> iterate = animals.iterator();
        System.out.print("ArrayBlockingQueue Elements: ");

        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

Salida

ArrayBlockingQueue: [Dog, Cat, Horse]
Accessed Element: Dog
ArrayBlockingQueue Elements: Dog, Cat, Horse,

Eliminar elementos

remove() - Devuelve y elimina un elemento especificado de la cola de bloqueo de matriz. Lanza una excepción si la cola está vacía.
poll() - Devuelve y elimina un elemento especificado de la cola de bloqueo de matriz. Devuelve null si la cola está vacía.
clear() - Elimina todos los elementos de la cola de bloqueo de matriz.

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);

        // 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 ArrayBlockingQueue: " + animals);
    }
}

Salida

ArrayBlockingQueue: [Dog, Cat, Horse]
Removed Elements:
Using remove(): Dog
Using poll(): Cat
Updated ArrayBlockingQueue: []

Método 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 agregar un elemento al final de una cola de bloqueo de matriz, podemos usar el put() método.

Si la cola de bloqueo de matrices está llena, espera hasta que haya espacio en la cola de bloqueo de matrices para agregar un elemento.

Por ejemplo,

import java.util.concurrent.ArrayBlockingQueue;

class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

       try {
        // Add elements to animals
           animals.put("Dog");
           animals.put("Cat");
           System.out.println("ArrayBlockingQueue: " + animals);
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}

Salida

ArrayBlockingQueue: [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 try..catch bloquear.

Método tomar()

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

Si la cola de bloqueo de matriz está vacía, espera hasta que haya elementos en la cola de bloqueo de matriz para eliminar.

Por ejemplo,

import java.util.concurrent.ArrayBlockingQueue;

class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

       try {
           //Add elements to animals
           animals.put("Dog");
           animals.put("Cat");
           System.out.println("ArrayBlockingQueue: " + animals);

           // Remove an element
           String element = animals.take();
           System.out.println("Removed Element: " + element);
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}

Salida

ArrayBlockingQueue: [Dog, Cat]
Removed Element: Dog

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 de matriz el elemento especificado.Si se encuentra el elemento, devuelve `true` , si no, devuelve `false` .
`size()`	Devuelve la longitud de la cola de bloqueo del arreglo.
`toArray()`	Convierte la cola de bloqueo de matriz en una matriz y la devuelve.
`toString()`	Convierte la cola de bloqueo de matriz en cadena

¿Por qué usar ArrayBlockingQueue?

El ArrayBlockingQueue utiliza matrices como su 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 de matriz puede hacer que el segundo subproceso espere hasta que el primer subproceso complete sus operaciones.

Cola de bloqueo de Java Java LinkedBlockingQueue

Java