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

CKTIS / Java

ThreadLocal: inicializar, definir, ler e remover valores por thread

Uma instância partilhada de `ThreadLocal` guarda um valor separado para cada thread. Depois de o remover, a leitura seguinte pode voltar a inicializá-lo, mas os objetos não são copiados.

Versão: Java SE 21

Sintaxe

java.lang.ThreadLocal<T> (Java SE 21)

import java.util.function.Supplier;

// Method signatures:
public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier)
public void set(T value)
public T get()
public void remove()

Em Java SE 21, várias threads podem utilizar a mesma instância de java.lang.ThreadLocal<T>, mas cada uma tem a sua própria entrada para essa instância. get(), set(T value) e remove() atuam apenas sobre a entrada da thread que chama o método.

O método estático ThreadLocal.withInitial(supplier) cria a instância sem chamar o fornecedor. Quando get() não encontra uma entrada para a thread atual, chama supplier.get(), guarda o resultado e devolve-o. set(value) guarda ou substitui o valor sem chamar o fornecedor, pelo que uma atribuição antes da primeira leitura evita a inicialização. set(null) guarda null; a entrada continua a existir. Passar null como fornecedor a withInitial lança uma NullPointerException.

remove() elimina a entrada sem a reinicializar de imediato. O próximo get() na mesma thread volta a chamar o fornecedor, a menos que entretanto seja executado set(...). Num conjunto de threads reutilizáveis, uma tarefa posterior na mesma thread pode ler um valor deixado por outra tarefa, e os dados podem ficar retidos mais tempo do que o necessário. Se a tarefa for responsável pela entrada, deve chamar remove() em finally na mesma thread.

As entradas são separadas, mas os objetos não o são necessariamente. Se o fornecedor devolver o mesmo objeto mutável às duas threads, ambas continuam a partilhá-lo. ThreadLocal não cria uma cópia profunda nem sincroniza o acesso ao objeto.

Exemplos

public class Main {
    private static final ThreadLocal<String> LOCAL =
            ThreadLocal.withInitial(() -> "default");

    public static void main(String[] args) throws InterruptedException {
        LOCAL.set("main-value");
        try {
            Thread worker = new Thread(() -> {
                try {
                    System.out.println("worker first get: " + LOCAL.get());
                    LOCAL.set(null);
                    System.out.println("worker after set(null): " + LOCAL.get());
                    LOCAL.remove();
                    System.out.println("worker after remove: " + LOCAL.get());
                } finally {
                    LOCAL.remove();
                }
            });
            worker.start();
            worker.join();
            System.out.println("main after join: " + LOCAL.get());
        } finally {
            LOCAL.remove();
        }
    }
}

Resultado

worker first get: default
worker after set(null): null
worker after remove: default
main after join: main-value

A thread de trabalho lê `default`, depois `null` após `set(null)` e de novo `default` após `remove()`. `join()` espera que termine antes de a thread principal imprimir o seu valor inalterado, `main-value`.

Lições relacionadas

  • Java · Lição 33 · Avançado · Versão: 2

Fontes