La clase ArrayBlockingQueue es miembro del marco de Java Collection. ArrayBlockingQueue es una cola de bloqueo limitada. El término acotado significa que el tamaño de la cola es fijo y no se puede cambiar. Cualquier intento de poner elemento/elementos en una cola completa conducirá a una operación de bloqueo. Del mismo modo, cualquier intento de eliminar elementos de una cola vacía dará lugar a una operación de bloqueo.
Esta función de tamaño límite de ArrayBlockingQueue se puede lograr pasando inicialmente capacidad como parámetro en el constructor de ArrayBlockingQueue. Esta cola ordena los elementos FIFO (first-in-first-out). Significa que los elementos se pueden insertar al final de la cola y se pueden quitar del principio de la cola.
La cola de la cola tiene el elemento más nuevo, mientras que la cabeza de la cola tiene el más antiguo.
Esta clase extiende AbstractQueue<E> e implementa las interfaces Serializable, Iterable<E>, Collection<E>, BlockingQueue<E>, Queue<E>.
Sintaxis:
clase pública ArrayBlockingQueue<E> extiende AbstractQueue<E> implementa BlockingQueue<E>, Serializable
// Aquí, E es el tipo de elementos almacenados en la colección
Operación básica
- add(E e): inserta el elemento especificado al final de esta cola si es posible hacerlo de inmediato 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(Consumer<? super E> action) – Realiza la acción dada para cada elemento del Iterable hasta que todos los elementos han sido procesados o la acción genera una excepción.
- iterator() : 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 de unidad de tiempo) : 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.
- put(E e) – Inserta el elemento especificado al final de esta cola, esperando que haya espacio disponible si la cola está llena.
- restanteCapacity() : devuelve la cantidad 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(Collection<?> c) – Elimina todos los elementos de esta colección que también están contenidos en la colección especificada (operación opcional).
- removeIf(Predicate<? super E> filter) – Elimina todos los elementos de esta colección que satisfacen el predicado dado.
- RetainAll(Collection<?> c) – Retiene solo los elementos de esta colección que están contenidos en la colección especificada (operación opcional).
- size() : devuelve el número de elementos en esta cola.
- spliterator() : devuelve un Spliterator sobre los elementos de esta cola.
- toArray() : devuelve una array que contiene todos los elementos de esta cola, en la secuencia adecuada.
- toArray(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.
- take() : recupera y elimina el encabezado de esta cola, esperando si es necesario hasta que un elemento esté disponible.
Java
import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;
public class ArrayBlockingQueueImpl<E> {
private ArrayBlockingQueue<E> arrayBlockingQueue;
// constructor to create object of ArrayBlockingQueue
// class with the specified capacity.
public ArrayBlockingQueueImpl(int cap)
{
arrayBlockingQueue = new ArrayBlockingQueue<E>(cap);
}
// constructor to create object of ArrayBlockingQueue
// class with the specified capacity and specified
// access policy.
public ArrayBlockingQueueImpl(int cap, boolean fair)
{
arrayBlockingQueue
= new ArrayBlockingQueue<>(cap, fair);
}
// constructor to create object of ArrayBlockingQueue
// class with the specified capacity and specified
// access initially containing the elements of the given
// collection.
public ArrayBlockingQueueImpl(
int cap, boolean fair,
Collection<? extends E> collection)
{
arrayBlockingQueue = new ArrayBlockingQueue<E>(
cap, fair, collection);
}
// method used to append a element to queue's
// tail.Return true upon successful operation else throw
// IllegalStateException if this queue reached capacity.
boolean add(E e) { return arrayBlockingQueue.add(e); }
// method used to removes all elements from the queue
void clear() { arrayBlockingQueue.clear(); }
// method used to check it queue contains specified
// element.
public boolean contains(Object o)
{
return arrayBlockingQueue.contains(o);
}
// method used clear the queue and add all the elements
// to specified collection.
public int drainTo(Collection<? super E> c)
{
return arrayBlockingQueue.drainTo(c);
}
// method used to remove at most specified number of
// elements from the queue and adds them to the
// specified collection.
public int drainTo(Collection<? super E> c,
int maxElements)
{
return arrayBlockingQueue.drainTo(c, maxElements);
}
// method used to return an iterator over the elements
// in the queue.This iterator could be used for
// traversing the element of queue.
public Iterator<E> iterator()
{
return arrayBlockingQueue.iterator();
}
// method used to append specified element to queue's
// tail.Return true upon successful operation else
// return false.
public boolean offer(E e)
{
return arrayBlockingQueue.offer(e);
}
// method used to insert the specified element at the
// tail of the queue
public boolean offer(E e, long timeout, TimeUnit unit)
throws InterruptedException
{
return arrayBlockingQueue.offer(e, timeout, unit);
}
// method used to get head of queue.Return NULL in case
// of empty queue.
public E peek() { return arrayBlockingQueue.peek(); }
// method used to remove head of the queue.Returns NULL
// if queue is empty else returns removed element.
public E poll() { return arrayBlockingQueue.poll(); }
// method used to remove head of this queue, waiting up
// to the specified wait time if necessary for an
// element to become available
public E poll(long timeout, TimeUnit unit)
throws InterruptedException
{
return arrayBlockingQueue.poll(timeout, unit);
}
// method used to inserts the specified element at
// queue's tail.
public void put(E e) throws InterruptedException
{
arrayBlockingQueue.put(e);
}
// method used to return number of additional elements
// that the queue can have without blocking.
public int remainingCapacity()
{
return arrayBlockingQueue.remainingCapacity();
}
// method used to remove single instance of the
// specified element from this queue
public boolean remove(Object o)
{
return arrayBlockingQueue.remove(o);
}
// method used to return size of queue.
public int size() { return arrayBlockingQueue.size(); }
// method used remove head of queue.Return NULL if queue
// is empty else return removed element.
public E take() throws InterruptedException
{
return arrayBlockingQueue.take();
}
// method used to return an array of the elements in
// this queue.
public Object[] toArray()
{
return arrayBlockingQueue.toArray();
}
// method used to return an array of the elements in
// this queue.
public <T> T[] toArray(T[] a)
{
return arrayBlockingQueue.toArray(a);
}
// method used to return string representation queue.
public String toString()
{
return arrayBlockingQueue.toString();
}
public static void main(String[] args)
{
// capacity of ArrayBlockingQueue
int capacity_queue = 10;
// fair value of queue.If fair value is if true then
// queue accesses for threads blocked on insertion or
// removal, are processed in FIFO order if false then
// access order is unspecified.
boolean fair = true;
// create object of ArrayBlockingQueue
ArrayBlockingQueue<String> queue
= new ArrayBlockingQueue<String>(capacity_queue,
fair);
// add element to the queue
queue.add("one");
queue.add("two");
queue.add("three");
queue.add("four");
queue.add("five");
// print queue
System.out.println(
"ArrayBlockingQueue (when fair policy is true):"
+ queue);
// print head element of queue
System.out.println("Peek element of the queue : "
+ queue.peek());
// delete the specified element from the queue
System.out.println(
"Deleting the element 'five' from the queue : "
+ queue.remove("five"));
// print queue
System.out.println("ArrayBlockingQueue :" + queue);
// clear the queue
queue.clear();
// print queue
System.out.println(
"ArrayBlockingQueue after clear operation :"
+ queue);
}
}
Producción
ArrayBlockingQueue (when fair policy is true):[one, two, three, four, five] Peek element of the queue : one Deleting the element 'five' from the queue : true ArrayBlockingQueue :[one, two, three, four] ArrayBlockingQueue after clear operation :[]
Publicación traducida automáticamente
Artículo escrito por Gunjanpaul y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA