KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

ArrayBlockingQueue(int): wachtrijcapaciteit en inactieve tijd

Maak een wachtrij met een vaste capaciteit van twee plaatsen en onderscheid die grens van een inactieve tijd van nul voor overtollige threads in de pool.

Versie: Java SE 21

Syntax

public ArrayBlockingQueue(int capacity)

// Java SE 21: a queue with two slots for waiting tasks
new ThreadPoolExecutor(1, 2, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(2))

In Java SE 21 maakt ArrayBlockingQueue(int) uit java.util.concurrent een lege, blokkerende wachtrij met een array als opslag en een vaste capaciteit. Met 2 passen er maximaal twee elementen tegelijk in; bij nul of een negatieve capaciteit volgt een IllegalArgumentException. Elementen worden in FIFO-volgorde uit de wachtrij gehaald, maar het standaardbeleid garandeert geen toegangsvolgorde voor wachtende threads. Gebruik de overload ArrayBlockingQueue(int, boolean) met true om wachtende threads in FIFO-volgorde toegang te geven.

Als de wachtrij vol is, geeft offer(E) meteen false terug zonder op ruimte te wachten, terwijl put(E) op ruimte wacht tenzij de thread wordt onderbroken. Als werkwachtrij van een ThreadPoolExecutor begrenst de capaciteit het aantal taken dat in de rij wacht, niet het aantal threads of het totale aantal geaccepteerde taken.

In de constructor van ThreadPoolExecutor is 0L een literal van het type long met waarde nul. De literal 0 heeft het type int en werkt voor deze parameter ook dankzij een verbredende conversie naar long. TimeUnit.MILLISECONDS is een enumconstante uit java.util.concurrent; een milliseconde is een duizendste seconde. Een inactieve tijd van 0L in deze eenheid betekent dat inactieve threads boven corePoolSize stoppen zonder op nieuw werk te wachten. Het is geen tijdslimiet voor taken. Kernthreads stoppen standaard niet wegens inactiviteit; allowCoreThreadTimeOut(true) vereist een positieve inactieve tijd.

Voorbeelden

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        var queue = new ArrayBlockingQueue<String>(2);
        System.out.println(queue.offer("A"));
        System.out.println(queue.offer("B"));
        System.out.println(queue.offer("C"));

        try (var executor = new ThreadPoolExecutor(
                1, 2, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(2))) {
            System.out.println("keepAliveMs=" + executor.getKeepAliveTime(TimeUnit.MILLISECONDS));
        }
    }
}

Resultaat

true
true
false
keepAliveMs=0

De zelfstandige wachtrij accepteert twee elementen en weigert het derde (`false`). De executor heeft een eigen wachtrij met twee plaatsen. Het programma leest `keepAliveMs=0` uit zonder taken uit te voeren of de levensduur van threads te meten.

Gerelateerde lessen

  • Java · Les 37 · Gevorderd · Versie: 2
  • Java · Les 42 · Gevorderd · Versie: 2

Bronnen