Clase ArrayBlockingQueue en Java

La clase ArrayBlockingQueue es una cola de bloqueo limitada respaldada por una array. Por acotado, significa que el tamaño de la Cola es fijo. Una vez creada, la capacidad no se puede cambiar. Los intentos de poner un elemento en una cola llena resultarán en el bloqueo de la operación. Del mismo modo, también se bloquearán los intentos de tomar un elemento de una cola vacía. El límite de ArrayBlockingQueue se puede lograr inicialmente omitiendo la capacidad como parámetro en el constructor de ArrayBlockingQueue. Esta cola ordena los elementos FIFO (primero en entrar, primero en salir) . 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.

Esta clase y su iterador implementan todos los métodos opcionales de las interfaces Collection e Iterator . Esta clase es miembro de Java Collections Framework .

La jerarquía de ArrayBlockingQueue
 

Hierarchy of ArrayBlockingQueue

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

Declaración 

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

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

Constructores de ArrayBlockingQueue

Aquí, la capacidad es el tamaño de la cola de bloqueo del arreglo.

1. ArrayBlockingQueue (capacidad int): crea un ArrayBlockingQueue con la capacidad (fija) dada y la política de acceso predeterminada. 

ArrayBlockingQueue<E> abq = new ArrayBlockingQueue<E>(int capacidad);

2. ArrayBlockingQueue(int capacity, boolean fair): crea un ArrayBlockingQueue con la capacidad dada (fija) y la política de acceso especificada. Si el valor razonable es verdadero, los accesos a la cola para subprocesos bloqueados en la inserción o eliminación se procesan en orden FIFO; si es falso, no se especifica el orden de acceso. 

ArrayBlockingQueue<E> abq = new ArrayBlockingQueue<E>(int capacidad, valor booleano);

3. ArrayBlockingQueue(int capacity, boolean fair, Collection c): crea un ArrayBlockingQueue con la capacidad (fija) dada, la política de acceso especificada y que inicialmente contiene los elementos de la colección dada, agregados en orden transversal del iterador de la colección. Si el valor razonable es verdadero, los accesos a la cola para subprocesos bloqueados en la inserción o eliminación se procesan en orden FIFO; si es falso, no se especifica el orden de acceso. 

ArrayBlockingQueue<E> abq = new ArrayBlockingQueue<E>(int capacidad, valor booleano, Colección c);

Ejemplo: 

Java

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

ArrayBlockingQueue:[1, 2, 3]

 

Operaciones básicas

1. Agregar elementos

El método add(E e) inserta el elemento pasado como parámetro al método al final de esta cola. Si agregar el elemento excede la capacidad de la cola, el método generará una IllegalStateException . Este método devuelve verdadero si la adición del elemento es exitosa; de lo contrario, arrojará una IllegalStateException.
 

Java

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

ArrayBlockingQueue:[1, 2, 3]

2. Eliminación de elementos

El método remove(Object o) elimina una única instancia del elemento especificado de esta cola si está presente. Podemos decir que el método elimina un elemento e tal que o.equals(e) si esta cola contiene uno o más elementos. El método Remove() devuelve verdadero si esta cola contenía el elemento especificado que queremos eliminar. 

Java

// Java program to demonstrate removal of 
// elements from an AbstractQueue
  
import java.util.concurrent.ArrayBlockingQueue;
  
public class RemovingElementsExample {
  
    public static void main(String[] args)
    {
        // define capacity of ArrayBlockingQueue
        int capacity = 15;
  
        // create object of ArrayBlockingQueue
        ArrayBlockingQueue<Integer> abq = new ArrayBlockingQueue<Integer>(capacity);
  
        // add  numbers
        abq.add(1);
        abq.add(2);
        abq.add(3);
  
        // print queue
        System.out.println("ArrayBlockingQueue:" + abq);
  
        // remove 223
        boolean response = abq.remove(2);
  
        // print Queue
        System.out.println("Removal of 2 :" + response);
  
        // print Queue
        System.out.println("queue contains " + abq);
  
        // remove all the elements
        abq.clear();
  
        // print queue
        System.out.println("ArrayBlockingQueue:" + abq);
    }
}
Producción

ArrayBlockingQueue:[1, 2, 3]
Removal of 2 :true
queue contains [1, 3]
ArrayBlockingQueue:[]

3. Accediendo a Elementos

El método peek() proporcionado por la interfaz Queue se usa para devolver el encabezado de la cola. Recupera, pero no elimina, la cabeza de esta cola. Si la cola está vacía, este método devuelve nulo.

Java

// Java program to demonstrate accessing
// elements of ArrayBlockingQueue
  
import java.util.concurrent.ArrayBlockingQueue;
  
public class AccessingElementsExample {
  
    public static void main(String[] args)
    {
  
        // Define capacity of ArrayBlockingQueue
        int capacity = 5;
  
        // Create object of ArrayBlockingQueue
        ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(capacity);
  
        // Add element to ArrayBlockingQueue
        queue.add(23);
        queue.add(32);
        queue.add(45);
        queue.add(12);
  
        // Print queue after adding numbers
        System.out.println("After adding numbers queue is ");
        System.out.println(queue);
  
        // Print head of queue using peek() method
        System.out.println("Head of queue " + queue.peek());
    }
}
Producción

After adding numbers queue is 
[23, 32, 45, 12]
Head of queue 23

4. Atravesando

El método iterator () de la clase ArrayBlockingQueue se usa para devolver un iterador de los mismos elementos que esta cola en una secuencia adecuada. Los elementos devueltos por este método contienen elementos en orden desde el primero (cabeza) hasta el último (cola). El iterador devuelto es débilmente coherente.

Java

// Java Program to Demonstrate iterating
// over ArrayBlockingQueue.
  
import java.util.concurrent.ArrayBlockingQueue;
import java.util.*;
  
public class TraversingExample {
  
    public static void main(String[] args)
    {
        // Define capacity of ArrayBlockingQueue
        int capacity = 5;
  
        // Create object of ArrayBlockingQueue
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<String>(capacity);
  
        // Add 5 elements to ArrayBlockingQueue
        queue.offer("User");
        queue.offer("Employee");
        queue.offer("Manager");
        queue.offer("Analyst");
        queue.offer("HR");
  
        // Print queue
        System.out.println("Queue is " + queue);
  
        // Call iterator() method and Create an iterator
        Iterator iteratorValues = queue.iterator();
  
        // Print elements of iterator
        System.out.println("\nThe iterator values:");
        while (iteratorValues.hasNext()) {
            System.out.println(iteratorValues.next());
        }
    }
}
Producción

Queue is [User, Employee, Manager, Analyst, HR]

The iterator values:
User
Employee
Manager
Analyst
HR

Métodos de ArrayBlockingQueue

Aquí, E es el tipo de elementos que se encuentran en esta colección .

MÉTODO

DESCRIPCIÓN

agregar​(E e) Inserta el elemento especificado al final de esta cola si es posible hacerlo inmediatamente sin exceder la capacidad de la cola, devolviendo verdadero en caso de éxito y lanzando una IllegalStateException si esta cola está llena.
clear() Elimina atómicamente todos los elementos de esta cola.
contiene​(Objeto o) Devuelve verdadero si esta cola contiene el elemento especificado.
drenajeA​(Colección<? super E> c) Elimina todos los elementos disponibles de esta cola y los agrega a la colección dada.
drenajeA​(Colección<? super E> c, int maxElements) Elimina como máximo el número dado de elementos disponibles de esta cola y los agrega a la colección dada.
forEach​(Consumidor<? super E> acción) Realiza la acción dada para cada elemento del iterable hasta que se hayan procesado todos los elementos o la acción genere una excepción.
iterador() Devuelve un iterador sobre los elementos de esta cola en la secuencia adecuada.
oferta​(E e) Inserta el elemento especificado al final de esta cola si es posible hacerlo inmediatamente sin exceder la capacidad de la cola, devolviendo verdadero en caso de éxito y falso si esta cola está llena.
oferta​(E e, tiempo de espera largo, unidad TimeUnit) Inserta el elemento especificado al final de esta cola, esperando hasta el tiempo de espera especificado para que haya espacio disponible si la cola está llena.
poner​(E e) Inserta el elemento especificado al final de esta cola, esperando que haya espacio disponible si la cola está llena.
capacidad restante() Devuelve el número de elementos adicionales que esta cola puede aceptar idealmente (en ausencia de restricciones de memoria o recursos) sin bloqueo.
eliminar​(Objeto o) Elimina una sola instancia del elemento especificado de esta cola, si está presente.
removeAll​(Colección<?> c) Elimina todos los elementos de esta colección que también están contenidos en la colección especificada (operación opcional).
removeIf​(predicado<? filtro super E>) Elimina todos los elementos de esta colección que satisfacen el predicado dado.
retenerTodo​(Colección<?> c) Retiene solo los elementos de esta colección que están contenidos en la colección especificada (operación opcional).
Talla() Devuelve el número de elementos en esta cola.
divisor() Devuelve un Spliterator sobre los elementos de esta cola.
aArray() Devuelve una array que contiene todos los elementos de esta cola, en la secuencia adecuada.
a la Array​(T[] a) Devuelve una array que contiene todos los elementos de esta cola, en la secuencia adecuada; el tipo de tiempo de ejecución de la array devuelta es el de la array especificada.

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

MÉTODO

DESCRIPCIÓN

addAll​(Colección<? extiende E> c) Agrega todos los elementos de la colección especificada a esta cola.
elemento() Recupera, pero no elimina, el encabezado de esta cola.
retirar() Recupera y elimina el encabezado de esta cola.

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

MÉTODO

DESCRIPCIÓN

contieneTodo​(Colección<?> c) Devuelve verdadero si esta colección contiene todos los elementos de la colección especificada.
esta vacio() Devuelve verdadero si esta colección no contiene elementos.
Enstringr() Devuelve una representación de string de esta colección.

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

MÉTODO

DESCRIPCIÓN

sondeo​(tiempo de espera prolongado, unidad TimeUnit) Recupera y elimina el encabezado de esta cola, esperando hasta el tiempo de espera especificado si es necesario para que un elemento esté disponible.
tomar() Recupera y elimina el encabezado de esta cola, esperando si es necesario hasta que un elemento esté disponible.

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

MÉTODO

DESCRIPCIÓN

addAll​(Colección<? extiende E> c) Agrega todos los elementos de la colección especificada a esta colección (operación opcional).
contieneTodo​(Colección<?> c) Devuelve verdadero si esta colección contiene todos los elementos de la colección especificada.
es igual a​(Objeto o) Compara el objeto especificado con esta colección para la igualdad.
código hash() Devuelve el valor del código hash para esta colección.
esta vacio() Devuelve verdadero si esta colección no contiene elementos.
flujoParalelo() Devuelve un Stream posiblemente paralelo con esta colección como fuente.
corriente() Devuelve un Stream secuencial con esta colección como fuente.
toArray​(IntFunction<T[]> generador) Devuelve una array que contiene todos los elementos de esta colección, utilizando la función de generador proporcionada para asignar la array devuelta.

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

MÉTODO

DESCRIPCIÓN

elemento() Recupera, pero no elimina, el encabezado de esta cola.
ojeada() Recupera, pero no elimina, el encabezado de esta cola o devuelve un valor nulo si esta cola está vacía.
encuesta() Recupera y elimina el encabezado de esta cola, o devuelve un valor nulo si esta cola está vacía.
retirar() Recupera y elimina el encabezado de esta cola.

Conclusión: ArrayBlockingQueue generalmente se usa en un entorno seguro para subprocesos en el que desea bloquear dos o más operaciones en un solo recurso, lo que permite solo un subproceso. Además, podemos bloquear un subproceso utilizando el factor de límite de capacidad.

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

Publicación traducida automáticamente

Artículo escrito por Code_r y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *