ThreadLocal est utilisé dans Java pour créer des variables de thread-privé, chaque thread a une copie indépendante pour éviter les problèmes de concurrence. Il stocke les valeurs via ThreadLocalmap à l'intérieur du fil. Faites attention au nettoyage en temps opportun lorsque vous l'utilisez pour éviter les fuites de mémoire. Les utilisations courantes incluent la gestion des sessions utilisateur, les connexions de la base de données, le contexte des transactions et le suivi des journaux. Les meilleures pratiques incluent: 1. Appelez le disque () pour le nettoyer après une utilisation; 2. évitez la surutilisation; 3. Héritage de réalité est nécessaire pour l'héritage des fils de l'enfant; 4. Ne stockez pas de gros objets. La valeur initiale peut être définie via initialValue () ou insitial (), et l'initialisation est retardée jusqu'au premier appel GET ().

Dans Java, ThreadLocal est une classe qui vous permet de créer des variables qui ne peuvent être accessibles qu'en un seul thread à la fois. Cela signifie que chaque thread a sa propre copie initialisée indépendamment de la variable. Il est utile lorsque vous souhaitez maintenir l'état dans un thread, tels que les détails d'authentification des utilisateurs, les connexions de base de données ou le contexte de transaction, sans se soucier des problèmes de concurrence.

Comment fonctionne le threadlocal

à la base, ThreadLocal fournit un moyen pour chaque thread d'avoir sa propre instance unique d'une variable. Lorsque vous définissez une valeur dans un ThreadLocal , il est stocké dans une carte cachée à l'intérieur de l'objet thread, clé par l'instance ThreadLocal elle-même.

Voici un exemple simple:

 ThreadLocal <string> threadLocal = new ThreadLocal <> ();
ThreadLocal.set ("Hello From Thread");
String Value = ThreadLocal.get ();

Chaque thread verra une valeur différente basée sur ce qu'elle a précédemment définie. Dans les coulisses, chaque fil conserve un ThreadLocalMap où ces valeurs sont stockées.

Une chose à garder à l'esprit: si vous oubliez de nettoyer après avoir utilisé un ThreadLocal , en particulier dans des environnements comme les serveurs Web où les threads sont réutilisés (comme les pools de threads), cela peut conduire à des fuites de mémoire. C'est pourquoi c'est une bonne pratique d'appeler remove() lorsque vous avez terminé.

Cas d'utilisation courants

Il y a plusieurs scénarios pratiques où ThreadLocal est utile:

• Gestion de la session utilisateur : stockage des données spécifiques à l'utilisateur pendant un cycle de vie de demande.
• Gestion de la connexion de la base de données : s'assurer que chaque thread utilise sa propre connexion sans partage.
• Contexte de transaction : garder une trace de l'état de transaction par thread.
• Journalisation MDC (contexte de diagnostic mappé) : utilisé dans les cadres de journalisation comme LOG4J ou SLF4J pour ajouter des informations contextuelles par thread.

Ces cas bénéficient d'une séparation propre entre les fils, ce qui évite les mécanismes de synchronisation et de verrouillage.

Meilleures pratiques et pièges

L'utilisation ThreadLocal n'est pas compliquée, mais il y a certaines choses à surveiller:

• Nettoyez toujours avec threadLocal.remove() une fois que vous avez terminé - en particulier dans les fils de longue durée ou les piscines de fil.
• Ne dépassez pas ThreadLocal . Cela peut sembler pratique, mais cela peut rendre les tests et le débogage plus difficiles car il masque les changements d'état.
• Soyez prudent avec l'héritage: ThreadLocal régulier ne transmet pas les valeurs aux fils de l'enfant. Si vous en avez besoin, utilisez InheritableThreadLocal .
• évitez de stocker de gros objets à moins que cela ne soit nécessaire, car ils resteront aussi longtemps que le fil.

N'oubliez pas non plus que ThreadLocal ne résout pas les problèmes d'état mutables partagés sur les threads - il les contourne en donnant à chaque thread sa propre version.

Initialisation des valeurs

Si vous souhaitez fournir une valeur initiale pour votre ThreadLocal au lieu de commencer avec NULL, vous pouvez remplacer la méthode initialValue() :

 ThreadLocal <Integer> ThreadLocal = ThreadLocal.WithInitial (() -> 1);

Ou en utilisant l'ancienne approche:

 ThreadLocal <Integer> ThreadLocal = new ThreadLocal <> () {
    @Outrepasser
    entier protégé initialValue () {
        retour 1;
    }
};

De cette fa?on, lorsqu'un thread accède d'abord à la variable via get() , il obtient la valeur initiale au lieu de Null. Il aide à éviter les vérifications nulles et à définir une valeur par défaut cohérente.

Gardez simplement à l'esprit que cette initialisation se produit paresseusement - la première fois get() est appelé pour un fil.

Fondamentalement, c'est tout.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!