introduction
Java fournit le package java.util.concurrent.atomique depuis JDK1.5, qui facilite les programmeurs pour effectuer des opérations atomiques sans verrouillage dans un environnement multi-thread. La couche sous-jacente de variables atomiques utilise des instructions atomiques fournies par le processeur, mais différentes architectures de CPU peuvent fournir des instructions atomiques différentes, et peuvent également nécessiter une forme de verrouillage interne, de sorte que cette méthode ne peut pas absolument garantir que le fil n'est pas bloqué.
Introduction du paquet atomique
Il y a 12 classes dans le package atomique, et quatre méthodes de mise à jour atomiques sont: les types de base de mise à jour atomique, les tableaux de mise à jour atomiques, les références de mise à jour atomique et les champs de mise à jour atomique. Les classes du package atomique sont essentiellement des classes enveloppées implémentées à l'aide de Dangel.
Classe de type de base de mise à jour atomique
Pour mettre à jour les types de base via des méthodes atomiques, le package atomique fournit les trois classes suivantes:
Atomicboolean: Atomic met à jour le type booléen.
ATOMICInteger: entier de mise à jour atomique.
ATOMICLONG: ATOMIC MISE À JOUR Long Intiger.
Les méthodes courantes d'AtomicInteger sont les suivantes:
int addandGet (int delta): ajoute la valeur d'entrée à la valeur de l'instance (valeur dans atomicInteger) de manière atomique et renvoie le résultat
Boolean ComparandDset (int attend, int update): si la valeur d'entrée est égale à la valeur attendue, définissez la valeur sur la valeur d'entrée atomiquement.
int getandincrement (): ajoute la valeur actuelle à 1 atomiquement. Remarque: La valeur renvoyée ici est la valeur avant l'auto-inointe.
void Lazyset (int newValue): il sera finalement défini sur NewValue. Après avoir utilisé LazySet pour définir la valeur, d'autres threads peuvent toujours être en mesure de lire l'ancienne valeur int GetandSet (int newValue): il est défini sur la valeur de NewValue de manière atomique et renvoie l'ancienne valeur.
L'exemple de code AtomicInteger est le suivant:
import java.util.concurrent.atomic.atomicinteger; classe publique atomicIntegerTest {static atomicInteger ai = new atomicInteger (1); public static void Main (string [] args) {System.out.println (ai.getandincrement ()); System.out.println (Ai.Get ();Sortir
12
Dessert après le dîner
Le package atomique fournit trois types de base de mises à jour atomiques, mais les types de base Java incluent le char, le flotteur et le double. La question est donc de savoir comment mettre à jour d'autres types d'atomes de base? Les classes du package atomique sont essentiellement implémentées à l'aide de dangers. Jetons un coup d'œil au code source de dangereux. Nous avons constaté que Unsafe fournit uniquement trois méthodes CAS, CompareAndSwapObject, CompareAndSwapint et CompareAndSwaplong. Regardez ensuite le code source d'Atomicboolean. Nous avons constaté qu'il convertit d'abord Boolean en entier, puis utilise CompareAndSwapint pour CAS, de sorte que la mise à jour atomique peut également être implémentée à l'aide d'idées similaires.
Classe de mise à jour atomique
Le package atomique fournit les trois classes suivantes:
AtomicIntegerArray: Antomiquement met à jour les éléments dans un tableau entier.
Atomiclongarray: Atomic met à jour les éléments dans les réseaux longs.
ATOMICREFERECENCEARRAY: Atomic met à jour les éléments dans le tableau de type de référence.
La classe AtomicIntegerArray fournit principalement Atomic pour mettre à jour les entiers dans le tableau. Les méthodes couramment utilisées sont les suivantes
int addandGet (int i, int delta): ajoute la valeur d'entrée atomiquement à l'index d'élément I dans le tableau.
booléen comparabledset (int i, int attend, int mette): si la valeur actuelle est égale à la valeur attendue, l'élément de la position du tableau I est atomiquement défini sur la valeur de mise à jour.
L'exemple de code est le suivant:
classe publique atomicIntegerArrayTest {static int [] value = new int [] {1, 2}; statique atomicIntegerArray Ai = new atomicIntegerArray (valeur); public static void main (String [] args) {ai.getandset (0, 3); System.out.println (ai.get (0)); System.out.println (valeur [0]);}}Sortir
31
Ce que vous devez noter dans la classe ATOMICIntegerArray, c'est que la valeur du tableau est transmise par le biais de la méthode du constructeur, puis atomicIntegerArray copiera le tableau actuel une copie, donc lorsque AtomicIntegerArray modifie les éléments du tableau interne, il n'affectera pas le tableau passé.
Type de référence de mise à jour atomique
AtomicInteger, qui est un type de base, ne peut mettre à jour qu'une seule variable. Si vous souhaitez mettre à jour plusieurs variables atomiquement, vous devez utiliser cet atome pour mettre à jour la classe fournie par le type de référence. Le package atomique fournit les trois classes suivantes:
Atomicreference: Atomic met à jour le type de référence.
AtomicreferenceFieldUpDater: atomic met à jour les champs dans le type de référence.
AtomicMarkableReference: Atomic met à jour le type de référence avec des bits de marqueur. Vous pouvez mettre à jour atomiquement un bit de balise de type booléen et un type de référence. La méthode de construction est atomicmarkablereference (v initialRef, booléen initialmark)
Le code d'utilisation de l'atomicure est le suivant:
classe publique atomicreferenceTest {public static atomicreference <serv> atomicUserRef = new atomicreference </serv> <serv> (); public static void main (string [] args) {user user = new User ("Conan", 15); atomicUserRef.set (utilisateur); user user upding = new user ("shinhichi", 17); atomicUserRef.CompaRedSet (utilisateur, mise à jour); System.out.println (atomicUserRef.get (). GetName ()); System.out.println (atomicUserRef.get (). Old;} public String getName () {Nom de retour;} public int getold () {return old;}}}Sortir
Shinichi17
Classe de terrain de mise à jour atomique
Si nous n'avons besoin que d'un certain champ dans une certaine classe, nous devons utiliser Atomic pour mettre à jour la classe de terrain. Le package atomique fournit les trois classes suivantes:
AtomicIntegerFieldUpDater: un Updater pour les champs qui mettent à jour atomiquement les entiers.
AtomiclongFieldUpDater: Un mises à jour pour les mises à jour atomiques longues champs entiers.
ATOMICSTAMPEDRERERFEFER: Atomic met à jour le type de référence avec un numéro de version. Cette classe associe des valeurs entières aux références et peut être utilisée pour plus de données atomiques et de numéros de version, ce qui peut résoudre les problèmes ABA qui peuvent survenir lors de l'utilisation de CAS pour les mises à jour atomiques.
Les classes de terrain de mise à jour atomique sont des classes abstraites, et chaque fois qu'ils sont utilisés, ils doivent utiliser la méthode statique NewupDater pour créer un Updater. Le modificateur public volatil doit être utilisé pour les champs de la classe de mise à jour atomique.
La première étape est que parce que les classes de terrain de mise à jour atomiques sont des classes abstraites, chaque fois que vous utilisez la méthode statique atomicIntegerFieldUpDater.newupDater, vous devez créer un mise à jour et vous devez définir les classes et les propriétés que vous souhaitez mettre à jour. La deuxième étape consiste à mettre à jour les champs (propriétés) de la classe doit utiliser le modificateur volatile public (privé volatile int ancy)
L'exemple de code d'AtomicIntegerFieldUpDater est le suivant:
classe publique atomicIntegerFieldUpDaterTest {private static atomicIntegerFieldupDater <ser utilis 10);System.out.println(a.getAndIncrement(conan));System.out.println(a.get(conan));}public static class User {private String name;public volatile int old;public User(String name, int old) {this.name = name;this.old = old;}public String getName() {return name;}public int getOld() {return old;}}}Sortir
1011
Résumer
Ce qui précède est l'intégralité du contenu de cet article sur l'introduction et l'utilisation du package atomique multithread Java. J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à ce site:
Introduction à la méthode d'écriture du modèle de consommation de production dans différentes conditions dans Java Multithreading
Java Multithread Programming Synchronizer Future et Futuretask Analyse et exemples de code
Une explication détaillée du verrouillage d'affichage multithread Java et du verrouillage intégré
S'il y a des lacunes, veuillez laisser un message pour le signaler.