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

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.

Fontes