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.