KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

SynchronousQueue — overdracht zonder buffer

Een SynchronousQueue draagt een element rechtstreeks over tussen threads. De bewerkingen put en take wachten op een passende partner in plaats van een buffer te gebruiken.

Versie: Java SE 21; repository runtime, production runtime not attested

Syntax

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> uit java.util.concurrent is een blokkerende wachtrij zonder capaciteit, zelfs niet voor één element. De wachtrij koppelt een producent aan een consument in plaats van elementen op te slaan.

SynchronousQueue.put wacht totdat een andere thread het element ontvangt; SynchronousQueue.take wacht op een overdracht en geeft het element terug. Zonder consument blokkeert put de aanroepende thread. Zolang put wacht, kan die thread de daaropvolgende aanroep van take niet bereiken, maar andere threads kunnen blijven draaien. Dat put is voltooid, betekent niet dat de verwerking is afgerond.

Beide methoden kunnen tijdens het wachten InterruptedException veroorzaken. Negeer onderbrekingen niet: geef de uitzondering door of herstel de interruptvlag en beëindig de taak. null is niet toegestaan. size() geeft altijd 0 terug en peek() altijd null.

Het voorbeeld voert put en take uit in twee verschillende threads. Het schrijft hello en daarna size=0 naar de uitvoer, ongeacht de volgorde waarin de threads worden gestart.

Voorbeelden

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();
        }
    }
}

Resultaat

hello
size=0

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen