WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

ArrayBlockingQueue(int): Warteschlangenkapazität und Leerlaufzeit

Erzeuge eine Warteschlange mit zwei festen Plätzen und unterscheide dieses Limit von einer Leerlaufzeit von null für zusätzliche Pool-Threads.

Version: 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 erzeugt ArrayBlockingQueue(int) aus java.util.concurrent eine leere, Array-basierte blockierende Warteschlange mit fester Kapazität. Mit 2 passen höchstens zwei Elemente gleichzeitig hinein; bei null oder einer negativen Kapazität wird eine IllegalArgumentException ausgelöst. Elemente werden in FIFO-Reihenfolge entnommen. Die Standardeinstellung garantiert aber keine Zugriffsreihenfolge für wartende Threads. Für FIFO-Zugriff unter wartenden Threads verwende die Überladung ArrayBlockingQueue(int, boolean) mit true.

Ist die Warteschlange voll, gibt offer(E) ohne Warten auf einen freien Platz false zurück. put(E) wartet dagegen auf einen freien Platz, sofern der Thread nicht unterbrochen wird. Als Arbeitswarteschlange eines ThreadPoolExecutor begrenzt die Kapazität die Zahl der dort wartenden Aufgaben, nicht die Zahl der Threads oder aller angenommenen Aufgaben.

Im Konstruktor von ThreadPoolExecutor ist 0L ein long-Literal mit dem Wert null. Das Literal 0 hat den Typ int und funktioniert hier ebenfalls durch Erweiterung zu long. TimeUnit.MILLISECONDS ist eine Enum-Konstante aus java.util.concurrent; eine Millisekunde ist eine Tausendstelsekunde. Bei 0L in dieser Einheit beenden sich untätige Threads oberhalb von corePoolSize, ohne auf neue Aufgaben zu warten. Das ist keine Zeitgrenze für Aufgaben. Kernthreads haben standardmäßig kein Leerlaufzeitlimit; allowCoreThreadTimeOut(true) setzt eine positive Leerlaufzeit voraus.

Beispiele

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

Ergebnis

true
true
false
keepAliveMs=0

Die separate Warteschlange nimmt zwei Elemente auf und weist das dritte ab (`false`). Der Executor hat eine eigene Warteschlange mit zwei Plätzen. Das Programm liest `keepAliveMs=0` aus, ohne Aufgaben auszuführen oder die Lebensdauer von Threads zu messen.

Zugehörige Lektionen

  • Java · Lektion 37 · Fortgeschritten · Version: 2
  • Java · Lektion 42 · Fortgeschritten · Version: 2

Quellen