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

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

Fontes