CKTIS / Java
BlockingQueue — uma fila com operações de espera
BlockingQueue<E> permite a troca segura de elementos entre threads, por exemplo, entre um produtor e um consumidor. Distingue operações que não esperam por espaço ou elementos, operações que esperam e variantes com limite de tempo. O exemplo utiliza uma ArrayBlockingQueue com capacidade 1.
Versão: Java SE 21; repository runtime, production runtime not attested
Sintaxe
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>, do pacote java.util.concurrent, estende Queue<E>. As suas implementações são seguras para utilização entre threads e servem, entre outros fins, para a comunicação produtor-consumidor. A capacidade e a ordem dependem da implementação: ArrayBlockingQueue tem capacidade fixa e ordem FIFO; a própria interface não garante FIFO.
BlockingQueue.offer(e) devolve true após a inserção ou false se não houver espaço. BlockingQueue.poll() remove e devolve o elemento no início, ou devolve null se a fila estiver vazia. BlockingQueue.peek() lê o elemento no início sem o remover e devolve null se a fila estiver vazia. Estas variantes não esperam por espaço nem por elementos. BlockingQueue.size() devolve o número de elementos, mas esse valor pode mudar antes da operação seguinte; não o utilize para verificar se uma inserção ou remoção posterior será bem-sucedida.
BlockingQueue.put(e) espera que haja espaço, enquanto BlockingQueue.take() espera por um elemento e remove-o. Podem esperar indefinidamente. As variantes offer(e, timeout, unit) e poll(timeout, unit) limitam a espera e devolvem false ou null, respetivamente, se o tempo se esgotar sem sucesso. As operações de espera declaram InterruptedException; propague a exceção ou trate a interrupção sem a ignorar silenciosamente.
Os elementos não podem ser null. As operações individuais sobre a fila são atómicas, mas uma sequência de chamadas não se torna atómica por isso. A interface não tem uma operação de fecho integrada; a terminação exige um protocolo separado.
O exemplo com uma única thread mostra de forma determinística os estados cheio e vazio. put e take podem concluir de imediato, pois há, respetivamente, espaço livre e um elemento disponível; o exemplo não demonstra espera entre threads.
Exemplos
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
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.