Introduction détaillée au partage de code utilisé par le package Atomic en Java

Introduction

Java fournit le package java.util.concurrent.atomic depuis JDK1.5 pour permettre aux programmeurs d'effectuer des opérations atomiques sans verrouillage dans un environnement multithread. La couche inférieure de la variable atomique utilise les instructions atomiques fournies par le processeur, mais différentes architectures de processeur peuvent fournir différentes instructions atomiques et peuvent également nécessiter une certaine forme de verrouillage interne, donc ceci La méthode ne peut pas garantir de manière absolue que le thread ne sera pas bloqué.

Introduction au package Atomic

Il existe 12 classes dans le package Atomic et quatre méthodes de mise à jour atomique, à savoir le type de base de mise à jour atomique, le tableau de mise à jour atomique, la référence de mise à jour atomique et le champ de mise à jour atomique. Les classes du package Atomic sont essentiellement des classes wrapper implémentées à l’aide de Unsafe.

Classe de type de base de mise à jour atomique

est utilisée pour mettre à jour les types de base de manière atomique. Le package Atomic fournit les trois classes suivantes :

• AtomicBoolean : mise à jour atomique. Type booléen.

• AtomicInteger : entier de mise à jour atomique.

• AtomicLong : Mise à jour atomique longue.

Les méthodes courantes d'AtomicInteger sont les suivantes :

• int addAndGet(int delta) : combine atomiquement la valeur d'entrée avec la valeur dans le instance (valeur dans AtomicInteger) est ajoutée et le résultat est renvoyé

• boolean compareAndSet(int expect, int update) : Si la valeur d'entrée est égale à la valeur attendue, la valeur est atomiquement défini sur la valeur saisie.

• int getAndIncrement() : ajoute atomiquement 1 à la valeur actuelle Remarque : la valeur renvoyée ici est la valeur avant l'incrément.

• void lazySet(int newValue) : il sera finalement défini sur newValue. Après avoir utilisé lazySet pour définir la valeur, d'autres threads pourront peut-être encore lire l'ancienne valeur dans un court laps de temps. du temps.

• int getAndSet(int newValue) : définit atomiquement la valeur sur newValue et renvoie l'ancienne valeur.

L'exemple de code AtomicInteger est le suivant :

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerTest {

	static AtomicInteger ai = new AtomicInteger(1);

	public static void main(String[] args) {
		System.out.println(ai.getAndIncrement());
		System.out.println(ai.get());
	}

}

Sortie

1
2

Dessert

Le package Atomic fournit trois Mises à jour atomiques des types de base, mais les types de base de Java incluent char, float, double, etc. La question est donc de savoir comment mettre à jour d’autres types de base de manière atomique ? Les classes du package Atomic sont essentiellement implémentées à l'aide de Unsafe. Jetons un coup d'œil au code source de Unsafe et constatons que Unsafe ne fournit que trois méthodes CAS, compareAndSwapObject, compareAndSwapInt et compareAndSwapLong. En regardant le code source d'AtomicBoolean, nous constatons qu'il s'agit du premier. convertit Boolean en un entier, puis utilise compareAndSwapInt pour effectuer CAS, de sorte que la mise à jour atomique de double peut également être implémentée en utilisant une idée similaire.

Classe de tableau de mise à jour atomique

Mettre à jour un élément du tableau de manière atomique Le package Atomic fournit les trois classes suivantes :

• AtomicIntegerArray : Mise à jour atomique de. éléments dans un tableau d’entiers.

• AtomicLongArray : met à jour atomiquement les éléments d'un long tableau d'entiers.

• AtomicReferenceArray : Mise à jour atomique des éléments dans un tableau de type référence.

La classe AtomicIntegerArray fournit principalement un moyen atomique de mettre à jour l'entier dans le tableau. Ses méthodes courantes sont les suivantes

• int addAndGet(int. i, int delta) : ajoute atomiquement la valeur d'entrée à l'élément à l'index i dans le tableau.

• boolean compareAndSet(int i, int expect, int update) : Si la valeur actuelle est égale à la valeur attendue, définissez atomiquement l'élément à la position du tableau i sur la valeur de mise à jour.

L'exemple de code est le suivant :

public class AtomicIntegerArrayTest {

	static int[] value = new int[] { 1, 2 };

	static AtomicIntegerArray ai = new AtomicIntegerArray(value);

	public static void main(String[] args) {
		ai.getAndSet(0, 3);
		System.out.println(ai.get(0));
                System.out.println(value[0]);
	}

}

Output

3
1

Classe AtomicIntegerArray Il est à noter que la valeur du tableau est passée via le constructeur Transmettez-le, puis AtomicIntegerArray fera une copie du tableau actuel, donc lorsque AtomicIntegerArray modifie les éléments internes du tableau, cela n'affectera pas le tableau entrant.

Type de référence de mise à jour atomique

La mise à jour atomique du type de base AtomicInteger ne peut mettre à jour qu'une seule variable. Si vous souhaitez mettre à jour plusieurs variables de manière atomique, vous devez utiliser la classe fournie par cette référence de mise à jour atomique. taper. Le package Atomic fournit les trois classes suivantes :

• AtomicReference : type de référence de mise à jour atomique.

• AtomicReferenceFieldUpdater : met à jour atomiquement les champs dans les types de référence.

• AtomicMarkableReference : Mise à jour atomique d'un type de référence avec un bit de marquage. Il est possible de mettre à jour atomiquement un bit d’indicateur booléen et un type de référence. La méthode de construction est AtomicMarkableReference(V initialRef, boolean initialMark)

L'exemple de code pour utiliser AtomicReference est le suivant :

public class AtomicReferenceTest {

	public static AtomicReference<user> atomicUserRef = new AtomicReference</user><user>();

	public static void main(String[] args) {
		User user = new User("conan", 15);
		atomicUserRef.set(user);
		User updateUser = new User("Shinichi", 17);
		atomicUserRef.compareAndSet(user, updateUser);
		System.out.println(atomicUserRef.get().getName());
		System.out.println(atomicUserRef.get().getOld());
	}

	static class User {
		private String name;
		private int old;

		public User(String name, int old) {
			this.name = name;
			this.old = old;
		}

		public String getName() {
			return name;
		}

		public int getOld() {
			return old;
		}
	}
}

Output

Shinichi
17

Classe de champ de mise à jour atomique

Si nous n'avons besoin que d'un certain champ dans une certaine classe, nous devons alors utiliser la classe de champ de mise à jour atomique. Le package Atomic fournit les trois classes suivantes :

.

• AtomicIntegerFieldUpdater : programme de mise à jour pour la mise à jour atomique des champs entiers.

• AtomicLongFieldUpdater : programme de mise à jour pour la mise à jour atomique des champs entiers longs.

• AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于原子的更数据和数据的版本号，可以解决使用CAS进行原子更新时，可能出现的ABA问题。

原子更新字段类都是抽象类，每次使用都时候必须使用静态方法newUpdater创建一个更新器。原子更新类的字段的必须使用public Volatile修饰符。AtomicIntegerFieldUpdater的例子代码如下：

public class AtomicIntegerFieldUpdaterTest {

	private static AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater
			.newUpdater(User.class, "old");

	public static void main(String[] args) {
		User conan = new User("conan", 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;
		}
	}
}

输出

10
11

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!