Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

PriorityBlockingQueue — uma fila de prioridade concorrente

PriorityBlockingQueue é uma fila de prioridade thread-safe e logicamente ilimitada. put insere sem esperar por espaço, enquanto take remove o elemento disponível mais pequeno e espera se a fila estiver vazia.

Versão: Java SE 21; repository runtime, production runtime not attested

Sintaxe

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

PriorityBlockingQueue<E>, do pacote java.util.concurrent, implementa BlockingQueue<E>. Ao contrário de PriorityQueue, é thread-safe. A remoção seleciona o elemento mais pequeno segundo a ordem natural ou um Comparator fornecido ao construtor, e não o elemento inserido primeiro. Para números na ordem natural, os valores mais pequenos são removidos primeiro.

PriorityBlockingQueue.put(E e) insere um elemento sem esperar que haja espaço: a fila é logicamente ilimitada. O parâmetro initialCapacity indica a capacidade inicial, não um limite para o número de elementos. Isto não proporciona controlo do fluxo; o esgotamento da memória pode causar OutOfMemoryError.

PriorityBlockingQueue.take() obtém e remove o início da fila. Se esta estiver vazia, espera pela disponibilidade de um elemento. Pode lançar InterruptedException, que deve ser tratada ou propagada. Em contrapartida, poll() devolve imediatamente null se a fila estiver vazia. A prioridade aplica-se aos elementos disponíveis nesse momento, não a futuras inserções nem à ordem pela qual os consumidores terminam o processamento.

Não são permitidos elementos null; elementos não comparáveis podem causar ClassCastException. Em caso de empate, não há garantia de ordem FIFO — usa uma chave secundária no comparador se essa ordem for necessária. A iteração não garante a ordem de prioridade. O exemplo insere todos os elementos antes de os remover, pelo que o resultado é determinístico.

Exemplos

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

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes