CKTIS / Java
BlockingQueue: una cola con operaciones de espera
BlockingQueue<E> permite intercambiar elementos de forma segura entre hilos, por ejemplo, entre un productor y un consumidor. Distingue las operaciones que no esperan a que haya espacio o elementos, las operaciones que esperan y las variantes con límite de tiempo. El ejemplo usa una ArrayBlockingQueue con capacidad 1.
Versión: Java SE 21; repository runtime, production runtime not attested
Sintaxis
BlockingQueue<E> queue = new ArrayBlockingQueue<>(capacity);
boolean accepted = queue.offer(element);
E removed = queue.poll();
queue.put(element); // throws InterruptedException
E received = queue.take(); // throws InterruptedException
E head = queue.peek();
int count = queue.size();
boolean acceptedInTime = queue.offer(element, timeout, unit);
E receivedInTime = queue.poll(timeout, unit);BlockingQueue<E>, del paquete java.util.concurrent, extiende Queue<E>. Sus implementaciones son seguras para usar entre hilos y sirven, entre otros usos, para la comunicación productor-consumidor. La capacidad y el orden dependen de la implementación: ArrayBlockingQueue tiene capacidad fija y orden FIFO; la interfaz en sí no garantiza FIFO.
BlockingQueue.offer(e) devuelve true después de añadir el elemento o false si no hay espacio. BlockingQueue.poll() elimina y devuelve el primer elemento, o devuelve null si la cola está vacía. BlockingQueue.peek() consulta el primer elemento sin eliminarlo y devuelve null si la cola está vacía. Estas variantes no esperan a que haya espacio ni elementos. BlockingQueue.size() devuelve el número de elementos, pero el valor puede cambiar antes de la siguiente operación; no lo uses para comprobar si una inserción o extracción posterior tendrá éxito.
BlockingQueue.put(e) espera a que haya espacio, mientras que BlockingQueue.take() espera a que haya un elemento y lo elimina. Pueden esperar indefinidamente. Las variantes offer(e, timeout, unit) y poll(timeout, unit) limitan la espera y devuelven false o null, respectivamente, si el tiempo se agota sin éxito. Las operaciones de espera declaran InterruptedException; propaga la excepción o gestiona la interrupción sin ignorarla silenciosamente.
Los elementos no pueden ser null. Cada operación de cola es atómica, pero una secuencia de llamadas no se vuelve atómica por ello. La interfaz no incluye una operación de cierre; para terminar se necesita un protocolo aparte.
El ejemplo de un solo hilo muestra de forma determinista los estados lleno y vacío. put y take pueden completarse inmediatamente porque, respectivamente, hay espacio libre y un elemento disponible; el ejemplo no muestra esperas entre hilos.
Ejemplos
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class Main {
public static void main(String[] args) throws InterruptedException {
BlockingQueue<String> queue = new ArrayBlockingQueue<>(1);
System.out.println(queue.offer("A"));
System.out.println(queue.offer("B"));
System.out.println(queue.peek());
System.out.println(queue.size());
System.out.println(queue.poll());
System.out.println(queue.poll());
queue.put("C");
System.out.println(queue.take());
System.out.println(queue.size());
}
}Resultado
true false A 1 A null C 0
El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.