Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

InheritableThreadLocal — ereditarietà dei valori locali al thread

InheritableThreadLocal<T> trasmette un valore iniziale da un thread padre a un thread figlio appena creato. L’ereditarietà avviene quando il thread viene creato, non con start() né quando un’attività viene inviata a un pool.

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

Sintassi

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

InheritableThreadLocal<T> del pacchetto java.lang estende ThreadLocal<T>. Un normale ThreadLocal inizializza il proprio valore in modo indipendente per ogni thread; questa sottoclasse consente a un figlio di ereditare il valore del padre. get(), set() e remove() agiscono sul valore del thread corrente; se non è stato impostato né ereditato alcun valore, il valore iniziale predefinito è null.

Il valore del figlio viene determinato quando si crea l’oggetto Thread, non quando si chiama start(). Il metodo sovrascrivibile protected T childValue(T parentValue) viene eseguito nel padre prima dell’avvio del figlio. Per impostazione predefinita restituisce l’argomento ricevuto: per gli oggetti significa la stessa reference, non una copia profonda. Un successivo set() in un thread non modifica l’associazione dell’altro thread, ma un oggetto mutabile può essere condiviso e richiedere sincronizzazione.

In Java SE 21, inheritInheritableThreadLocals(false) su Thread.Builder disabilita l’ereditarietà; per impostazione predefinita è attiva. Il momento in cui avviene l’ereditarietà comporta un’importante limitazione: un thread di lavoro già presente in un pool non riceve un nuovo contesto per ogni attività. Non usare questo meccanismo per propagare automaticamente il contesto delle richieste a un pool. Pulisci i valori con remove() in un blocco finally; così viene rimosso solo il valore del thread corrente.

L’esempio usa valori String immutabili: il padre modifica il proprio valore dopo aver creato il figlio, ma prima di start(). Il figlio legge comunque at-creation e il suo set() non sostituisce il valore del padre. join() garantisce che il figlio termini prima che venga stampata la riga del padre.

Esempi

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

Risultato

child: at-creation
parent: after-creation

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti