WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

BlockingQueue – eine Warteschlange mit wartenden Operationen

BlockingQueue<E> ermöglicht den threadsicheren Austausch von Elementen, etwa zwischen Produzent und Konsument. Sie bietet Operationen, die nicht auf Platz oder Elemente warten, wartende Operationen sowie Varianten mit Zeitlimit. Das Beispiel verwendet eine ArrayBlockingQueue mit Kapazität 1.

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

Syntax

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> aus java.util.concurrent erweitert Queue<E>. Implementierungen sind threadsicher und eignen sich unter anderem für die Kommunikation zwischen Produzent und Konsument. Kapazität und Reihenfolge hängen von der Implementierung ab: ArrayBlockingQueue hat eine feste Kapazität und FIFO-Reihenfolge; die Schnittstelle selbst garantiert FIFO nicht.

BlockingQueue.offer(e) gibt nach dem Einfügen true zurück oder false, wenn kein Platz verfügbar ist. BlockingQueue.poll() entfernt das erste Element und gibt es zurück oder liefert bei leerer Warteschlange null. BlockingQueue.peek() liest das erste Element, ohne es zu entfernen, und liefert bei einer leeren Warteschlange null. Diese Varianten warten weder auf Platz noch auf Elemente. BlockingQueue.size() gibt die Anzahl der Elemente zurück, doch dieser Wert kann sich vor der nächsten Operation ändern. Verwende ihn nicht, um zu prüfen, ob ein späteres Einfügen oder Abrufen erfolgreich sein wird.

BlockingQueue.put(e) wartet auf freien Platz, während BlockingQueue.take() auf ein Element wartet und es entfernt. Beide können unbegrenzt warten. Die Varianten offer(e, timeout, unit) und poll(timeout, unit) begrenzen die Wartezeit und geben bei erfolglosem Ablauf der Zeit false beziehungsweise null zurück. Wartende Operationen deklarieren InterruptedException; gib die Ausnahme weiter oder behandle die Unterbrechung, ohne sie stillschweigend zu ignorieren.

Elemente dürfen nicht null sein. Einzelne Warteschlangenoperationen sind atomar, eine Folge von Aufrufen wird dadurch jedoch nicht atomar. Die Schnittstelle besitzt keine eingebaute Schließoperation; zum Beenden ist ein separates Protokoll erforderlich.

Das Beispiel mit einem Thread zeigt auf reproduzierbare Weise den vollen und den leeren Zustand. put und take können sofort abgeschlossen werden, da jeweils freier Platz beziehungsweise ein verfügbares Element vorhanden ist. Das Beispiel zeigt kein Warten zwischen Threads.

Beispiele

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

Ergebnis

true
false
A
1
A
null
C
0

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen