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

CKTIS / Java

SynchronousQueue — transferência sem buffer

Uma SynchronousQueue transfere um elemento diretamente entre threads. As operações put e take aguardam um parceiro correspondente, em vez de utilizarem um buffer.

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

Sintaxe

SynchronousQueue<E> queue = new SynchronousQueue<>();

// Producer thread:
queue.put(value); // throws InterruptedException

// Consumer thread (a different thread using the same queue):
E valueReceived = queue.take(); // throws InterruptedException

SynchronousQueue<E> de java.util.concurrent é uma fila bloqueante sem capacidade, nem sequer para um único elemento. Liga um produtor a um consumidor em vez de armazenar elementos.

SynchronousQueue.put aguarda até que outra thread receba o elemento; SynchronousQueue.take aguarda uma transferência e devolve o elemento. Sem um consumidor, put bloqueia a thread que o chamou. Enquanto put está à espera, essa thread não pode chegar à chamada seguinte a take, mas as outras threads podem continuar a executar-se. A conclusão de put não significa que o processamento terminou.

Ambos os métodos podem lançar InterruptedException enquanto aguardam. Não ignores as interrupções: propaga a exceção ou restaura o sinalizador de interrupção e termina a tarefa. null não é permitido. size() devolve sempre 0 e peek() devolve sempre null.

O exemplo executa put e take em duas threads distintas. Apresenta hello e, em seguida, size=0, independentemente da ordem pela qual são iniciadas.

Exemplos

import java.util.concurrent.SynchronousQueue;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        SynchronousQueue<String> queue = new SynchronousQueue<>();
        Thread producer = new Thread(() -> {
            try {
                queue.put("hello");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        producer.start();
        try {
            String value = queue.take();
            producer.join();
            System.out.println(value);
            System.out.println("size=" + queue.size());
        } finally {
            producer.interrupt();
            producer.join();
        }
    }
}

Resultado

hello
size=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