Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

InheritableThreadLocal — héritage des valeurs locales à un thread

InheritableThreadLocal<T> transmet une valeur initiale d’un thread parent à un thread enfant nouvellement créé. L’héritage a lieu lors de la création du thread, et non à l’appel de start() ni lors de la soumission d’une tâche à un pool.

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

Syntaxe

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

InheritableThreadLocal<T> du paquet java.lang étend ThreadLocal<T>. Un ThreadLocal ordinaire initialise sa valeur indépendamment pour chaque thread ; cette sous-classe permet à un enfant d’hériter de la valeur du parent. get(), set() et remove() agissent sur la valeur du thread courant ; en l’absence de valeur définie ou héritée, la valeur initiale par défaut est null.

La valeur de l’enfant est déterminée lors de la création de l’objet Thread, et non à l’appel de start(). La méthode redéfinissable protected T childValue(T parentValue) s’exécute dans le parent avant le démarrage de l’enfant. Par défaut, elle renvoie son argument : pour les objets, il s’agit de la même référence, et non d’une copie profonde. Un appel ultérieur à set() dans un thread ne modifie pas l’association de l’autre thread, mais un objet mutable peut être partagé et nécessiter une synchronisation.

Dans Java SE 21, inheritInheritableThreadLocals(false) sur Thread.Builder désactive l’héritage ; il est activé par défaut. Le moment où l’héritage se produit implique une limite importante : un thread de travail déjà présent dans un pool ne reçoit pas un nouveau contexte pour chaque tâche. N’utilisez pas ce mécanisme pour propager automatiquement le contexte d’une requête vers un pool. Nettoyez les valeurs avec remove() dans un bloc finally ; cela supprime uniquement la valeur du thread courant.

L’exemple utilise des valeurs String immuables : le parent modifie sa valeur après avoir créé l’enfant, mais avant start(). L’enfant lit toujours at-creation, et son propre set() ne remplace pas la valeur du parent. join() garantit que l’enfant a terminé avant l’affichage de la ligne du parent.

Exemples

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

Résultat

child: at-creation
parent: after-creation

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources