Tel est le principe de la discussion correcte scénarios locaux et d'application

Bien comprendre et appliquer les principes de la discussion scène locale

Le présent document décrit les exemples locaux discussion des principes et des méthodes de mise en uvre et analyse ses scénarios d'application.

ThreadLocal résoudre tous les problèmes

Depuis paradigme de soutien ThreadLocal, comme ThreadLocal <  StringBuilder > , Pour faciliter la présentation, avec plus tard variable ThreadLocal au nom de lui-même, mais avec Exemples  Des exemples représentatifs de types spécifiques de (par exemple) StringBuidler a.

Pas bien compris

L'une des raisons pour écrire cet article est que beaucoup blogue en ligne sur ThreadLocal de scénarios d'application et la résolution de problèmes, la description est pas clair, même faux. Les éléments suivants sont communs pour l'introduction de ThreadLocal

ThreadLocal fournir un nouveau but idées ThreadLocal pour résoudre le problème des programmes multi-thread concurrents est un problème commun à résoudre lorsque plusieurs threads d'accéder à une ressource

Il existe de nombreux articles comparant les similitudes et les différences dans la ThreadLocal et synchronisation. Comme il est à titre de comparaison, il devrait être considéré à la fois pour résoudre les problèmes identiques ou similaires.

La description ci-dessus, le problème est, ThreadLocal ne résout pas le multi-thread Partagé  Des variables. Étant donné que la variable n'est pas partagée, il est beaucoup moins de problèmes de synchronisation.

La compréhension correcte

variables ThreadLoal, son principe de base est les mêmes objets contenus dans ThreadLocal (sur ThreadLocal <  chaîne > Qui est, en termes de type de variable chaîne), il existe différentes copies dans différents fil (en fait une autre instance, il sera décrit en détail plus loin). Voici quelques points à noter

• En raison de sa propre copie de chaque instance de discussion, et la copie ne peut utiliser par le thread courant. C'est aussi l'origine du nom ThreadLocal
• Étant donné que chaque instance a sa propre copie de fil, de fil et d'autres inaccessibles, il serait partagé entre plusieurs threads est pas un problème
• Ni part, comment synchroniser le problème, comment résoudre le problème par exemple de synchronisation?

Ce ThreadLocal à la fin résolu le problème, mais aussi pour ce genre de scène?

Cette classe fournit des variables locales de thread. Ces variables diffèrent de leurs homologues normales en ce que chaque thread accède à un (via sa méthode GET ou ensemble) a son propre que, indépendamment initialisé copie de la variable. Instances ThreadLocal sont généralement des champs statiques privés dans les classes ce souhait à l'état associé avec un fil (par exemple, un ID utilisateur ou ID de transaction) fil .Chaque détient une référence implicite à sa copie d'une variable de thread local aussi longtemps que le fil est vivant et l'instance ThreadLocal est accessible, après un fil va, toutes ses copies des instances locales de thread sont soumis à la collecte des ordures (à moins que d'autres références à ces copies existent).

Le sens de base

ThreadLocal fournit des instances locales de thread. Il se distingue des variables ordinaires que chaque thread utilisera la variable d'initialisation d'une instance complètement séparé des copies. la variable ThreadLocal est habituellement modification `de static` privé. Au bout d'un fil, toutes les instances de copie ThreadLocal relative, il utilise peut être recyclé.

Dans l'ensemble, Des exemples de ThreadLocal adapté chaque nécessite son propre fil séparé et l'instance pour être utilisé dans plusieurs méthodes, à savoir espacement variable entre les fils et partagé entre scènes méthode ou classe .

Cela sera expliqué plus loin en détail par des vues par exemple. En outre, dans ce scénario, il est essentiel de ne pas utiliser ThreadLocal, sinon complètement le même effet peut être obtenu, de manière à atteindre plus compact, mais ThreadLocal.

utilisation ThreadLocal

Le code exemple

ThreadLocal mode de réalisation sera décrit ci-dessous en utilisant le code suivant

étude de cas

ThreadLocal se soutient paradigme. Ce mode de réalisation utilise un type de variable ThreadLocal StringBuilder. Méthode disponible () lit par exemple StringBuidler ThreadLocal via le get, StringBuilder peut être fournie par un ensemble de méthode (T t).

Le code ci-dessus sont des résultats suit comme

Nom du fil: fil - 1, ThreadLocal hashcode: 372282300, instance hashcode: 418873098, Valeur: Nom 0Thread: fil - 3, ThreadLocal hashcode: 372282300, instance hashcode: 1609588821, Valeur: nom 0Thread: fil - 2, ThreadLocal hashcode: 372282300, instance hashcode: 1780437710, Valeur: nom 0Thread: fil - 3, ThreadLocal hashcode: 372282300, instance hashcode: 1609588821, Valeur: nom 01Thread: fil - 1, ThreadLocal hashcode: 372282300, instance hashcode: 418873098, Valeur: nom 01Thread: fil - 3, ThreadLocal hashcode: 372282300, instance hashcode: 1609588821, Valeur: nom 012Thread: fil - 3, ThreadLocal hashcode: 372282300, instance hashcode: 1609588821, Valeur: 0123Set, nom du fil: fil - 3, ThreadLocal hashcode: 372282300, instance hashcode: 1362597339, Valeur: bonjour nom du worldThread: fil - 2, ThreadLocal hashcode: 372282300, instance hashcode: 1780437710, Valeur: nom 01Thread: fil - 1, ThreadLocal hashcode: 372282300, instance hashcode: 418873098, Valeur: nom 012Thread: fil - 2, ThreadLocal h ashcode: 372282300, instance hashcode: 1780437710, Valeur: nom 012Thread: fil - 1, ThreadLocal hashcode: 372282300, instance hashcode: 418873098, Valeur: nom 0123Thread: fil - 2, ThreadLocal hashcode: 372282300, instance hashcode: 1780437710, Valeur: 0123Set , le nom du fil: fil - 1, ThreadLocal hashcode: 372282300, instance hashcode: 482932940, Valeur: bonjour worldSet, nom du fil: fil - 2, ThreadLocal hashcode: 372282300, instance hashcode: 1691922941, Valeur: Bonjour tout le monde

Comme on peut le voir ci-dessus de la sortie

• 1-3 vu depuis la ligne de sortie, chaque fil dans la méthode get () ThreadLocal pour obtenir les différentes instances StringBuilder
• 1-3 montrent des lignes de sortie que chaque fil est le même que l'accès à une variable ThreadLocal
• 7,12,13 sortie de la ligne 30 et la ligne de code pour être visible, bien que tous le champ statique compteur classe compteur est get () à partir du code obtenu instance de StringBuilder et annexant la chaîne, mais ce n'est pas ajouté tous les threads chaînes StringBuilder sont mis dans le même, mais chaque thread supplémentaire une chaîne dans les exemples de StringBuidler intérieurs respectifs
• Après la première ligne et la deuxième ligne de comparaison 15 et la ligne de sortie 38 peut être vu en conjonction avec l'utilisation de la méthode set (T t), l'instance de StringBuilder points variables sont remplacés ThreadLocal

mappage d'instance ThreadLocal et du fil de maintien

Étant donné que chaque fil a son propre accès à la variable ThreadLocal d'une copie d'instance « locale ». Une solution possible est de maintenir une carte ThreadLocal, est le fil conducteur clé, sa valeur dans l'instance de fil. Obtenez le fil à travers le système ThreadLocal () pour obtenir par exemple, il vous suffit de clé dans un fil, vous pouvez trouver l'instance correspondante de la carte. Le mode de réalisation tel que représenté sur la Fig.

Le programme peut répondre aux exigences mentionnées ci-dessus chaque thread une sauvegarde séparée. Chaque nouveau thread pour accéder au ThreadLocal, vous devez ajouter une carte à une carte, et à la fin de chaque fil, la carte devrait effacer. Ici, il y a deux problèmes:

• Augmenter et fil de fil de réduction nécessaire pour écrire la carte, de sorte que la nécessité de veiller à ce que le coffre-fort de fil Carte. Bien que de l'évolution ConcurrentHashMap de l'article Java technologie de base multi-thread décrit plusieurs façons d'atteindre la carte de thread-safe, mais il a besoin de plus ou moins serrures pour assurer le fil de sécurité
• Au bout du fil, la nécessité de veiller à ce que toutes les visites ThreadLocal il les cartes correspondantes sont supprimées, il peut provoquer une fuite de mémoire. (Plus tard, nous allons introduire des méthodes pour éviter les fuites de mémoire)

Les problèmes de verrouillage où, n'est pas une cause du régime employé JDK.

entretien du fil et la cartographie ThreadLocal instance

Dans la solution ci-dessus, le problème de verrouillage apparaît parce que plusieurs threads accèdent à la même carte. Si la carte maintenue par fil, de sorte que chaque fil d'accès que leur propre carte, puis écrire problème multi-thread, il n'y a pas de verrou de besoin n'existe pas. Le mode de réalisation tel que représenté sur la Fig.

Bien que le programme ne problème ne verrou, mais parce que après chaque fil pour accéder à une variable ThreadLocal maintiendra la mise en correspondance des exemples de variables et spécifiques ThreadLocal dans leur propre carte, si vous ne supprimez pas ces références (cartes), celles-ci ne peuvent pas être recyclés ThreadLocal il peut provoquer une fuite de mémoire. Plus tard JDK présentera comment résoudre le problème.

ThreadLocal mis en oeuvre dans le JDK 8

fuite de mémoire ThreadLocalMap

Dans ce mode de réalisation, carte fournie par une classe interne statique ThreadLocal classe ThreadLocalMap. Des exemples de cet entretien ThreadLocal carte une instance spécifique. Et la différence est HashMap que chaque entrée ThreadLocalMap est une paire lien  référence faible, il peut être vu de super (k). De plus, chaque entrée comprend une paire valeur La référence forte.

La raison d'utiliser des références faibles est que, lorsqu'il n'y a pas de point de référence à l'intensité variable ThreadLocal, qui peut être recyclé, ce qui évite les problèmes ci-dessus ont provoqué des fuites de mémoire ThreadLocal ne peuvent pas être récupérées.

Cependant, cela est aussi un autre type de problème de fuite de mémoire qui peuvent survenir. ThreadLocalMap maintient la cartographie variables ThreadLocal et des exemples spécifiques, lorsque la variable ThreadLocal est récupérée, la carte clé devient nulle, qui ne peut être retiré d'entrée. par exemple l'entrée est telle que la mémoire de fuite de référence ne peut pas être récupéré.

Remarque: Entrée Bien que référence faible, mais il est faible des références de type ThreadLocal (à savoir, il est au-dessus lien référence faible), plutôt que les faibles exemples spécifiques de référence, il est impossible d'éviter les fuites de mémoire liées aux exemples de spécifiques.

Exemple de lecture

Des exemples du procédé comme suit

La lecture exemple, le fil lui-même est d'abord acquise par ThreadLocalMap procédé getMap (t). De la définition du processus se trouve ci-dessous, il est un exemple de ce champ ThreadLocalMap classe Thread, à savoir la mise en correspondance entretenue par l'objet Thread exemple spécifique ThreadLocal, ce qui est conforme à l'analyse ci-dessus.

Après avoir obtenu ThreadLocalMap, `procédé ThreadLocal d'obtenir le fil correspondant à l'entrée de courant ThreadLocalMap by` map.getEntry (ce). La méthode de cette objets ThreadLocal actuellement accessibles.

Entrée acquise sinon nulle, sont les valeurs extraites de l'entrée dans le présent exemple correspond à au filetage de l'accès requis. Des exemples spécifiques de réglage de la valeur initiale de la variable correspondant au filetage ThreadLocal si l'entrée est nulle, acquise par la méthode `setInitialValue ()`.

Définir la valeur initiale

Définir une valeur initiale comme suit

Cette méthode est des méthodes privées ne peuvent pas être surchargées.

Première méthode, () pour obtenir les valeurs initiales `` initialValue. Cette méthode est publique, et le return null par défaut. Par conséquent, la méthode d'utilisation typique souvent surchargé. À savoir, l'exemple à l'intérieur dont la surcharge classe anonyme.

ThreadLocalMap puis obtenir le fil correspondant à l'objet, si l'objet est non nul, alors l'instance d'objet ThreadLocal de mise en correspondance directe correspondant à la valeur initiale ThreadLocalMap ajoutée au fil. Si elle est nulle, l'objet est d'abord créé puis mis en correspondance ThreadLocalMap les ajouter.

Il n'a pas besoin d'examiner les questions de sécurité de fil ThreadLocalMap de. Parce que chaque fil a un et un seul objet ThreadLocalMap, et seul le fil qu'ils y ont accès, les autres threads ne seront pas accéder au ThreadLocalMap, à savoir, l'objet est partagé dans plusieurs threads, il n'y aurait pas de problèmes de sécurité du fil.

L'exemple

En plus de la méthode prévue par le initialValue () est la valeur initiale d'un exemple, le procédé peut aussi être mis en réglant la valeur de l'instance de fil, comme indiqué ci-dessous.

Procédé pour acquérir l'objet ThreadLocalMap le fil, puis l'exemple de la destination de mappage de l'addition directe des objets ThreadLocal (à savoir, ce code) dans le ThreadLocalMap. Bien sûr, si la cartographie existe déjà, la couverture directe. De plus, si l'ThreadLocalMap acquise est nulle, créer l'objet ThreadLocalMap.

Empêcher les fuites de mémoire

Pour les objets ThreadLocal ne sont plus utilisés et ont été récupérés, dont des exemples correspondant à chaque fil dans le fil en raison ThreadLocalMap d'entrée de solides références, ne peut pas être récupéré, il peut provoquer une fuite de mémoire.

Pour résoudre ce problème, une méthode ThreadLocalMap SET, la méthode par replaceStaleEntry toutes les clés définies à l'entrée de la valeur NULL est nulle, de sorte que la valeur peut être récupérée. En outre, la clé sera nulle et la valeur est réglée sur zéro par l'entrée expungeStaleEntry procédé de mouture de sorte que le procédé peut être récupéré d'entrée. De cette manière, les fuites de mémoire ThreadLocal peuvent être évités.

scène applicable

Comme décrit ci-dessus, ThreadLocal applicable aux deux scénarios suivants

• Chaque thread a besoin de sa propre instance distincte
• Exemples doivent être partagées dans plusieurs méthodes, mais ne veulent pas être multi-thread mutualisé

Sur le premier point, chaque thread a son propre exemple, se rendre compte qu'il est beaucoup de façons. Il peut être construit, par exemple, une instance séparée à l'intérieur fil. ThreadLoca peut répondre à la demande sous une forme très pratique.

Pour le deuxième point, le premier point peut être (chaque fil possède sa propre instance) condition est satisfaite, la forme de référence adopté par le procédé inter-mis en oeuvre. ThreadLocal abaisser le couplage de tels codes, et d'obtenir une plus élégante.

cas

Pour les applications Java Web, Session enregistrer beaucoup d'informations. Ont souvent besoin d'accès à l'information par le biais de la session, il y a des moments où ils ont besoin de modifier la séance d'information. D'une part, la nécessité de veiller à ce que chaque thread a sa propre instance de session séparée. D'autre part, en raison de la nécessité d'opérer dans de nombreuses parties de session, il y a plusieurs façons de partager session de la demande. Dans le cas contraire à l'aide du ThreadLocal, chaque fil peut être construit dans une instance de session, et l'instance parmi une pluralité de modes de transmission, comme illustré ci-dessous.

Cette méthode peut être atteint besoins. Mais chacune de session si nécessaire, requièrent une transmission explicite objet Session, plus le degré de couplage entre les méthodes.

Tel qu'il est utilisé ici, re-mettre en uvre la fonction ThreadLocal comme indiqué ci-dessous.

Après la transformation de code à l'aide ThreadLocal, plus besoin de passer l'objet de session entre les différentes méthodes, et aussi très facile à faire en sorte que chaque thread a sa propre instance distincte.

Si vous regardez beaucoup d'entre eux à un moment donné, des méthodes alternatives. Par exemple, en créant une variable locale dans le fil peut être réalisé chaque thread a son propre exemple, l'utilisation de variables statiques peuvent être partagées entre les variables dans la méthode. Mais si vous voulez rencontrer des variables partagées entre l'isolement et les méthodes entre les threads, ThreadLocal très approprié.

résumé

• ThreadLocal ne résout pas le problème du partage des données entre les threads
• ThreadLocal par créer implicitement une copie distincte des cas dans différents threads pour éviter l'exemple des questions de sécurité des threads
• Chaque thread détient et gère un mappage Carte ThreadLocal objets avec des exemples spécifiques, la carte est due uniquement à maintenir son accès fil, donc il n'y a pas thread-safe et des problèmes de verrouillage
• ThreadLocalMap d'entrée est une référence à la référence faible ThreadLocal, objet ThreadLocal est d'éviter le problème ne peut pas être récupéré
• ThreadLocalMap l'ensemble récupéré clé de valeur nulle objet Entrée en appelant la méthode de replaceStaleEntry (à savoir exemple spécifique) et pour empêcher l'objet lui-même des fuites de mémoire d'entrée
• ThreadLocal appliquer à l'isolement variable entre les fils et partagé parmi les méthodes de scène