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

CKTIS / Java

PriorityBlockingQueue — una cola de prioridad concurrente

PriorityBlockingQueue es una cola de prioridad segura para hilos y lógicamente ilimitada. put inserta sin esperar a que haya espacio, mientras que take retira el elemento disponible más pequeño y espera si la cola está vacía.

Versión: Java SE 21; repository runtime, production runtime not attested

Sintaxis

PriorityBlockingQueue<E> queue = new PriorityBlockingQueue<>();
PriorityBlockingQueue<E> ordered = new PriorityBlockingQueue<>(initialCapacity, comparator);
queue.put(element);
E next = queue.take(); // throws InterruptedException

PriorityBlockingQueue<E>, del paquete java.util.concurrent, implementa BlockingQueue<E>. A diferencia de PriorityQueue, es segura para hilos. Al recuperar un elemento, selecciona el menor según el orden natural o un Comparator proporcionado al constructor, no el que se insertó primero. Para números en orden natural, se recuperan primero los valores menores.

PriorityBlockingQueue.put(E e) inserta un elemento sin esperar a que haya espacio: la cola es lógicamente ilimitada. El parámetro initialCapacity indica la capacidad inicial, no un límite para el número de elementos. Esto no proporciona control de flujo; el agotamiento de memoria puede provocar OutOfMemoryError.

PriorityBlockingQueue.take() recupera y elimina la cabeza de la cola. Si está vacía, espera a que haya un elemento. Puede lanzar InterruptedException, que debe gestionarse o propagarse. En cambio, poll() devuelve null inmediatamente si la cola está vacía. La prioridad se aplica a los elementos disponibles en ese momento, no a las inserciones futuras ni al orden en que los consumidores terminan de procesar.

No se permiten elementos null; los elementos no comparables pueden provocar ClassCastException. En caso de empate, no se garantiza el orden FIFO: usa una clave secundaria en el comparador si necesitas ese orden. La iteración no garantiza el orden de prioridad. El ejemplo inserta todos los elementos antes de recuperarlos, por lo que el resultado es determinista.

Ejemplos

import java.util.concurrent.PriorityBlockingQueue;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        PriorityBlockingQueue<Integer> queue = new PriorityBlockingQueue<>(2);
        queue.put(30);
        queue.put(10);
        queue.put(20);

        System.out.println(queue.take());
        System.out.println(queue.take());
        System.out.println(queue.take());
        System.out.println(queue.poll());
    }
}

Resultado

10
20
30
null

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.

Fuentes