CKTIS / Java
BlockingQueue: inserir, retirar e consultar elementos
Escolhe entre operações imediatas, esperas com limite e esperas sem limite de tempo. Aprende a consultar a fila e a distinguir a ordem FIFO da ordem de prioridade.
Versão: Java SE 21
Sintaxe
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> é uma fila segura para utilização por várias threads, útil para passar trabalho de produtores para consumidores. offer(e) não espera por espaço: devolve true se inserir o elemento ou false se não houver espaço. offer(e, timeout, unit) espera por espaço se necessário e devolve false se o prazo terminar antes de haver espaço. put(e) tem tipo de retorno void e, se necessário, espera por espaço sem limite de tempo.
poll() retira e devolve o elemento à cabeça da fila ou devolve null se a fila estiver vazia, sem esperar por um elemento. poll(timeout, unit) também retira e devolve o elemento à cabeça, mas pode esperar e devolve null se o prazo terminar sem que haja um elemento disponível. take() retira e devolve o elemento à cabeça, esperando se necessário sem limite de tempo. Ambas as sobrecargas com prazo usam TimeUnit, como em 1, TimeUnit.MILLISECONDS. Essas sobrecargas, put e take lançam InterruptedException se a thread for interrompida durante a espera.
peek(), herdado de Queue, devolve o elemento à cabeça sem o retirar, ou null se a fila estiver vazia. size(), herdado de Collection, devolve o número de elementos como int, não a capacidade. Se a fila contiver mais de Integer.MAX_VALUE elementos, o método devolve Integer.MAX_VALUE. Outra thread pode alterar a fila entre chamadas: size() > 0 não garante que um take() posterior não tenha de esperar. Inserir null com offer ou put lança NullPointerException.
ArrayBlockingQueue tem capacidade fixa; LinkedBlockingQueue permite indicar um limite de capacidade. Ambas seguem a ordem FIFO: dos elementos ainda na fila, sai primeiro aquele que entrou primeiro. A interface não garante a ordem FIFO. PriorityBlockingQueue retira o menor elemento segundo a ordem natural ou um comparador fornecido, sem garantir a ordem em caso de empate. Não tem um limite de capacidade intrínseco, pelo que put e offer com prazo não esperam por espaço nessa fila.
Exemplos
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
Dois elementos enchem a fila FIFO. `peek()` mostra `20`, mas o tamanho continua a ser `2`. `take()` retira `20` e depois `poll()` retira `10`. As duas chamadas com prazo de `1` ms mostram os resultados em caso de insucesso, não o tempo decorrido. A fila de prioridade retira primeiro `10`.
Lições relacionadas
- Java · Lição 37 · Avançado · Versão: 2