ThreadLocal résout des exemples de programmes multithread

Je pense que les lecteurs ont également lu beaucoup d'informations sur ThreadLocal sur Internet. De nombreux blogs ont dit ceci : ThreadLocal propose une nouvelle façon de penser pour résoudre le problème de concurrence. programmes multithreads. ;Le but de ThreadLocal est de résoudre le problème de partage lorsque plusieurs threads accèdent aux ressources. Si vous le pensez, donnez-vous 10 secondes pour dissiper vos précédents malentendus à propos de ThreadLocal !
Regardez comment le code source dans JDK est écrit :

This class provides thread-local variables. These variables differ from
their normal counterparts in that each thread that accesses one (via its
{@code get} or {@code set} method) has its own, independently initialized
copy of the variable. {@code ThreadLocal} instances are typically private
static fields in classes that wish to associate state with a thread (e.g.,
a user ID or Transaction ID).

La traduction est probablement comme ceci (l'anglais n'est pas bon, si vous avez une meilleure traduction, veuillez laisser un message) :

La classe ThreadLocal est utilisée pour fournir des variables locales dans le thread. Lorsque ce type de variable est accessible dans un environnement multithread (accessible via la méthode get ou set), cela peut garantir que les variables de chaque thread sont relativement indépendantes des variables des autres threads. Les instances ThreadLocal sont généralement de type statique privé et sont utilisées pour associer des threads et des contextes de thread.

peut être résumé en une phrase : La fonction de ThreadLocal est de fournir des variables locales au sein du thread. Ce type de variable fonctionne dans le cycle de vie du thread, réduisant certaines variables communes entre plusieurs fonctions ou composants dans. le même fil conducteur. La complexité du transfert.
Par exemple, quand je sors, je dois d'abord prendre le bus, puis le métro. Ici, prendre le bus et prendre le métro sont comme deux fonctions dans le même fil. Je dois compléter les deux. fonctions. La même chose : carte de bus (les bus et métros de Pékin utilisent des cartes de bus), puis pour ne pas transmettre la variable de la carte de bus aux deux fonctions (équivalent à ne pas toujours avoir la carte de bus sur la route), je peux faire ceci : La carte de bus est remise à l'avance à une agence, et lorsque j'ai besoin de glisser la carte, je demande la carte de bus à cette agence (bien sûr, je reçois à chaque fois la même carte de bus). De cette façon, tant que j'ai (le même fil) besoin d'une carte de bus, je peux la demander à cette organisation à tout moment et n'importe où.

Quelqu'un veut dire : vous pouvez définir la carte de bus comme variable globale, afin de pouvoir obtenir la carte de bus à tout moment et n'importe où, n'est-ce pas ? Mais que se passe-t-il s’il y a de nombreux individus (de nombreux fils de discussion) ? Tout le monde ne peut pas tous utiliser la même carte de bus (on suppose que la carte de bus est authentifiée par son vrai nom), sinon ce sera chaotique. Comprenez-vous maintenant ? C'est l'intention initiale de la conception de ThreadLocal : fournir des variables locales au sein du thread, accessibles à tout moment et n'importe où dans ce thread, tout en isolant les autres threads.

(1) ThreadContext fournit une méthode pour lier et dissocier des objets pour le thread actuel en fonction de paires clé/valeur.

Cette classe fournit des variables locales de thread. Ces variables sont différentes des variables ordinaires dans la mesure où chaque thread accédant à un thread (via sa méthode get ou set) possède sa propre copie initialisée indépendamment de la variable.

Une instance ThreadLocal est généralement un champ statique privé dans une classe qui souhaite associer un état à un thread (par exemple : un utilisateur ID ou ID de transaction). Chaque fil a une référence implicite à une copie de la variable locale du fil,

Tant que le fil est vivant, l'instance ThreadLocal est accessible ; après la mort d'un thread, toutes les copies de l'instance locale du thread seront récupérées (sauf si d'autres références existent).

est l'objet enregistré dans le fil de discussion. Autrement dit, une classe T est un attribut de classe d'un thread.

Les méthodes couramment utilisées sont :

 1 public class ThreadLocal<T> { 2  3 //设置属性 4  5 public void set(T value) { 6 Thread t = Thread.currentThread(); 7 ThreadLocalMap map = getMap(t); 8 if (map != null) 9 map.set(this, value);10 else11 createMap(t, value);12 }13 14 //获取属性15 16 public T get() {17 Thread t = Thread.currentThread();18 ThreadLocalMap map = getMap(t);19 if (map != null) {20 ThreadLocalMap.Entry e = map.getEntry(this);21 if (e != null)22 return (T)e.value;23 }24 return setInitialValue();25 }26 27 //获取线程的 ThreadLocal.ThreadLocalMap28 29 ThreadLocalMap getMap(Thread t) {30 return t.threadLocals;31 }32 33 }34 35 //新建一个线程本地的localMap36 37 void createMap(Thread t, T firstValue) {38 t.threadLocals = new ThreadLocalMap(this, firstValue);39 }

(2) Exemples d'utilisation : la connexion et la session sont les suivantes :

 1 private static ThreadLocal<Connection> connectionHolder 2 = new ThreadLocal<Connection>() { 3 public Connection initialValue() { 4     return DriverManager.getConnection(DB_URL); 5 } 6 }; 7   8 public static Connection getConnection() { 9 return connectionHolder.get();10 }

 1 private static final ThreadLocal threadSession = new ThreadLocal(); 2   3 public static Session getSession() throws InfrastructureException { 4     Session s = (Session) threadSession.get(); 5     try { 6         if (s == null) { 7             s = getSessionFactory().openSession(); 8             threadSession.set(s); 9         }10     } catch (HibernateException ex) {11         throw new InfrastructureException(ex);12     }13     return s;14 }