KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

BlockingQueue — een wachtrij met wachtende bewerkingen

BlockingQueue<E> maakt het mogelijk om veilig elementen uit te wisselen tussen threads, bijvoorbeeld tussen een producent en een consument. De interface onderscheidt bewerkingen die niet wachten op ruimte of elementen, wachtende bewerkingen en varianten met een tijdslimiet. Het voorbeeld gebruikt een ArrayBlockingQueue met capaciteit 1.

Versie: 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> uit java.util.concurrent breidt Queue<E> uit. Implementaties zijn thread-safe en worden onder meer gebruikt voor communicatie tussen producent en consument. Capaciteit en volgorde zijn afhankelijk van de implementatie: ArrayBlockingQueue heeft een vaste capaciteit en FIFO-volgorde; de interface zelf garandeert geen FIFO.

BlockingQueue.offer(e) geeft na het toevoegen true terug, of false als er geen ruimte is. BlockingQueue.poll() verwijdert en geeft het eerste element terug, of geeft null terug als de wachtrij leeg is. BlockingQueue.peek() leest het eerste element zonder het te verwijderen en geeft null terug als de wachtrij leeg is. Deze varianten wachten niet op ruimte of elementen. BlockingQueue.size() geeft het aantal elementen terug, maar die waarde kan vóór de volgende bewerking veranderen. Gebruik deze waarde niet om te controleren of een latere toevoeging of verwijdering zal slagen.

BlockingQueue.put(e) wacht tot er ruimte is, terwijl BlockingQueue.take() wacht op een element en dat verwijdert. Ze kunnen onbeperkt wachten. De varianten offer(e, timeout, unit) en poll(timeout, unit) beperken de wachttijd en geven respectievelijk false of null terug als de tijd verstrijkt zonder succes. Wachtende bewerkingen declareren InterruptedException; geef de uitzondering door of handel de onderbreking af zonder die stilzwijgend te negeren.

Elementen mogen niet null zijn. Afzonderlijke wachtrijbewerkingen zijn atomair, maar een reeks aanroepen wordt daardoor niet atomair. De interface heeft geen ingebouwde sluitbewerking; beëindiging vereist een apart protocol.

Het voorbeeld met één thread toont op deterministische wijze de volle en lege toestand. put en take kunnen direct worden voltooid, omdat er respectievelijk ruimte en een element beschikbaar zijn; het voorbeeld laat geen wachten tussen threads zien.

Voorbeelden

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

Resultaat

true
false
A
1
A
null
C
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