Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

InheritableThreadLocal — herança de valores locais ao thread

InheritableThreadLocal<T> transmite um valor inicial de um thread pai para um thread filho acabado de criar. A herança ocorre quando o thread é criado, não em start() nem quando uma tarefa é submetida a um conjunto de threads.

Versão: Java SE 21; repository runtime, production runtime not attested

Sintaxe

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

InheritableThreadLocal<T> do pacote java.lang estende ThreadLocal<T>. Um ThreadLocal normal inicializa o seu valor de forma independente para cada thread; esta subclasse permite que um filho herde o valor do pai. get(), set() e remove() atuam sobre o valor do thread atual; se não existir um valor definido ou herdado, o valor inicial predefinido é null.

O valor do filho é determinado quando o objeto Thread é criado, não quando se chama start(). O método que pode ser redefinido, protected T childValue(T parentValue), é executado no pai antes de o filho arrancar. Por predefinição, devolve o argumento recebido: no caso dos objetos, isso significa a mesma referência, não uma cópia profunda. Um set() posterior num thread não altera a associação do outro thread, mas um objeto mutável pode ser partilhado e exigir sincronização.

Em Java SE 21, inheritInheritableThreadLocals(false) em Thread.Builder desativa a herança; por predefinição, está ativada. O momento em que a herança ocorre implica uma limitação importante: um thread de trabalho já existente num conjunto não recebe um contexto novo para cada tarefa. Não uses este mecanismo para propagar automaticamente o contexto de pedidos para um conjunto de threads. Limpa os valores com remove() num bloco finally; isto remove apenas o valor do thread atual.

O exemplo utiliza valores String imutáveis: o pai altera o seu valor depois de criar o filho, mas antes de start(). O filho continua a ler at-creation, e o seu próprio set() não substitui o valor do pai. join() garante que o filho termina antes de ser impressa a linha do pai.

Exemplos

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

Resultado

child: at-creation
parent: after-creation

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes