Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

BlockingQueue: insertar, extraer y consultar elementos

Elige entre operaciones inmediatas, esperas con plazo y esperas sin plazo. Aprende a consultar la cola y a distinguir el orden FIFO del orden por prioridad.

Versión: Java SE 21

Sintaxis

java.util.concurrent.BlockingQueue<E> — Java SE 21
boolean offer(E e);
boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException;
E poll();
E poll(long timeout, TimeUnit unit) throws InterruptedException;
void put(E e) throws InterruptedException;
E take() throws InterruptedException;
E peek();
int size();

java.util.concurrent.BlockingQueue<E> es una cola segura para varios hilos, útil para pasar trabajo de productores a consumidores. offer(e) no espera a que haya espacio: devuelve true si inserta el elemento y false si no hay sitio. offer(e, timeout, unit) espera espacio si es necesario y devuelve false si se agota el plazo antes de que haya sitio. put(e) tiene tipo de retorno void y espera espacio, si hace falta, sin límite de tiempo.

poll() extrae y devuelve el elemento de la cabeza, o devuelve null si la cola está vacía, sin esperar a que llegue un elemento. poll(timeout, unit) también extrae y devuelve el elemento de la cabeza, pero puede esperar y devuelve null si se agota el plazo sin que haya un elemento disponible. take() extrae y devuelve el elemento de la cabeza y espera, si hace falta, sin límite de tiempo. Ambas sobrecargas con plazo usan TimeUnit, como en 1, TimeUnit.MILLISECONDS. Estas sobrecargas, put y take lanzan InterruptedException si el hilo se interrumpe durante la espera.

peek(), heredado de Queue, devuelve el elemento de la cabeza sin extraerlo, o null si la cola está vacía. size(), heredado de Collection, devuelve el número de elementos como int, no la capacidad. Si la cola contiene más de Integer.MAX_VALUE elementos, el método devuelve Integer.MAX_VALUE. Otro hilo puede cambiar la cola entre llamadas: size() > 0 no garantiza que un take() posterior no espere. Insertar null con offer o put lanza NullPointerException.

ArrayBlockingQueue tiene capacidad fija; LinkedBlockingQueue permite indicar un límite de capacidad. Ambas siguen el orden FIFO: entre los elementos aún en cola, se extrae primero el que se insertó antes. La interfaz no garantiza FIFO. PriorityBlockingQueue extrae el elemento menor según el orden natural o un comparador proporcionado, sin garantizar el orden de los empates. No tiene un límite de capacidad intrínseco, por lo que su put y su offer con plazo no esperan espacio.

Ejemplos

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.TimeUnit;

public class BlockingQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> fifo = new ArrayBlockingQueue<>(2);
        fifo.put(20);
        System.out.println("offer with space: " + fifo.offer(10));
        System.out.println("offer when full: " + fifo.offer(30));
        System.out.println("timed offer when full: "
                + fifo.offer(30, 1, TimeUnit.MILLISECONDS));
        System.out.println("peek: " + fifo.peek());
        System.out.println("size after peek: " + fifo.size());
        System.out.println("take: " + fifo.take());
        System.out.println("poll: " + fifo.poll());
        System.out.println("poll when empty: " + fifo.poll());
        System.out.println("timed poll when empty: "
                + fifo.poll(1, TimeUnit.MILLISECONDS));

        BlockingQueue<Integer> priority = new PriorityBlockingQueue<>();
        priority.put(20);
        priority.put(10);
        System.out.println("priority take: " + priority.take());
    }
}

Resultado

offer with space: true
offer when full: false
timed offer when full: false
peek: 20
size after peek: 2
take: 20
poll: 10
poll when empty: null
timed poll when empty: null
priority take: 10

Dos elementos llenan la cola FIFO. `peek()` muestra `20`, pero el tamaño sigue siendo `2`. `take()` extrae `20` y luego `poll()` extrae `10`. Las dos llamadas con plazo de `1` ms muestran los resultados cuando la operación no se completa, no el tiempo transcurrido. La cola de prioridad extrae primero `10`.

Lecciones relacionadas

  • Java · Lección 37 · Avanzado · Versión: 2

Fuentes