WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

InheritableThreadLocal — Vererbung threadlokaler Werte

InheritableThreadLocal<T> übergibt einen Anfangswert vom Elternthread an einen neu erstellten Kindthread. Die Vererbung erfolgt beim Erstellen des Threads, nicht bei start() oder beim Übergeben einer Aufgabe an einen Threadpool.

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

Syntax

InheritableThreadLocal<T> context = new InheritableThreadLocal<>();
context.set(value);
T current = context.get();
context.remove();
// Optional override: protected T childValue(T parentValue)

InheritableThreadLocal<T> aus java.lang erweitert ThreadLocal<T>. Ein gewöhnliches ThreadLocal initialisiert seinen Wert für jeden Thread unabhängig; diese Unterklasse ermöglicht es einem Kindthread, den Wert des Elternthreads zu erben. get(), set() und remove() betreffen den Wert des aktuellen Threads; ohne gesetzten oder geerbten Wert ist der anfängliche Standardwert null.

Der Wert des Kindthreads wird beim Erstellen des Thread-Objekts festgelegt, nicht bei start(). Die überschreibbare Methode protected T childValue(T parentValue) wird im Elternthread ausgeführt, bevor der Kindthread startet. Standardmäßig gibt sie ihr Argument zurück: Bei Objekten bedeutet das dieselbe Referenz, keine tiefe Kopie. Ein späteres set() in einem Thread ändert die Bindung des anderen Threads nicht, aber ein veränderbares Objekt kann gemeinsam genutzt werden und Synchronisierung erfordern.

In Java SE 21 lässt sich die Vererbung mit inheritInheritableThreadLocals(false) auf Thread.Builder deaktivieren; standardmäßig ist sie aktiviert. Der Zeitpunkt der Vererbung bringt eine wichtige Einschränkung mit sich: Ein bereits vorhandener Workerthread eines Pools erhält nicht für jede Aufgabe einen neuen Kontext. Verwenden Sie diesen Mechanismus nicht zur automatischen Weitergabe des Anfragekontexts an einen Pool. Räumen Sie Werte mit remove() in finally auf; dadurch wird nur der Wert des aktuellen Threads entfernt.

Das Beispiel verwendet unveränderliche String-Werte: Der Elternthread ändert seinen Wert nach dem Erstellen des Kindthreads, aber vor start(). Der Kindthread liest weiterhin at-creation, und sein eigenes set() ersetzt nicht den Wert des Elternthreads. join() stellt sicher, dass der Kindthread beendet ist, bevor die Zeile des Elternthreads ausgegeben wird.

Beispiele

public class Main {
    private static final InheritableThreadLocal<String> CONTEXT =
            new InheritableThreadLocal<>();

    public static void main(String[] args) throws InterruptedException {
        CONTEXT.set("at-creation");
        try {
            Thread child = new Thread(() -> {
                try {
                    System.out.println("child: " + CONTEXT.get());
                    CONTEXT.set("child-only");
                } finally {
                    CONTEXT.remove();
                }
            });
            CONTEXT.set("after-creation");
            child.start();
            child.join();
            System.out.println("parent: " + CONTEXT.get());
        } finally {
            CONTEXT.remove();
        }
    }
}

Ergebnis

child: at-creation
parent: after-creation

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