Programmation simultanée Java : analyse des exemples d'utilisation d'AtomicInteger Atomic Integer de JUC Toolkit

La classe AtomicInteger stocke une valeur int en bas et fournit des méthodes pour effectuer des opérations atomiques sur la valeur int. AtomicInteger a été introduit dans Java 1.5 dans le cadre du package java.util.concurrent.atomic. java.util.concurrent.atomic包的一部分，从Java 1.5开始引入。

1. AtomicInteger基础用法

通过下文的AtomicInteger构造方法，可以创建一个AtomicInteger对象，该对象的初始值默认为0。AtomicInteger提供get和set方法，获取底层int整数值，与设置int整数值

//初始值为0的atomicInteger对象
AtomicInteger atomicInteger = new AtomicInteger();  
//初始值为200的atomicInteger对象
AtomicInteger atomicInteger = new AtomicInteger(200);
int currentValue = atomicInteger.get();         //100
atomicInteger.set(2453);                        //现在的值是 2453

但是上面的方法，对于AtomicInteger而言并不是它的核心内容，AtomicInteger核心内容体现在它的原子性，我们下文介绍。

2. 什么时候需要使用AtomicInteger

我们通常在以下的两种场景下使用AtomicInteger

多线程并发场景下操作一个计数器，需要保证计数器操作的原子性。

进行数值比较，如果给定值与当前值相等，进行数值的更新操作，并实现操作的非阻塞算法。

2.1. 原子计数器场景

把AtomicInteger作为一个计数器使用，AtomicInteger提供了若干方法进行加法、减法的原子操作。

比如从一个map里面获取值，用get()方法，这是第一个操作；获取到值之后给这个值加上n，这是第二个操作；将进行过加法运算的值，再次放入map里面是第三个操作。所谓操作的原子性是指：在多线程并发的场景下，上面的三个操作是原子性的，也就是不可分割的。不会出现A线程get了数值，B线程同时也get到了该数值，两个线程同时为该值做运算并先后再次放入的情况，这种情况对于AtomicInteger而言是不会出现的，AtomicInteger操作是线程安全的、不可分割的。

addAndGet()- 将给定的值加到当前值上，并在加法后返回新值，并保证操作的原子性。

getAndAdd()- 将给定的值加到当前值上，并返回旧值，并保证操作的原子性。

incrementAndGet()- 将当前值增加1，并在增加后返回新值。它相当于++i操作，并保证操作的原子性。

getAndIncrement()- 将当前值增加1并返回旧值。相当于++i操作，并保证操作的原子性。

decrementAndGet()- 将当前值减去1，并在减去后返回新值，相当于i--操作，并保证操作的原子性。

getAndDecrement()- 将当前值减去1，并返回旧值。它相当于 --i操作，并保证操作的原子性。

下面是AtomicInteger原子性操作方法的例子

public class Main {
    public static void main(String[] args) {
        //初始值为100的atomic Integer
        AtomicInteger atomicInteger = new AtomicInteger(100);
        System.out.println(atomicInteger.addAndGet(2));         //加2并返回102
        System.out.println(atomicInteger);                      //102
        System.out.println(atomicInteger.getAndAdd(2));         //先获取102，再加2
        System.out.println(atomicInteger);                      //104
        System.out.println(atomicInteger.incrementAndGet());    //加1再获取105   
        System.out.println(atomicInteger);                      //105   
        System.out.println(atomicInteger.getAndIncrement());    //先获取105再加1
        System.out.println(atomicInteger);                      //106
        System.out.println(atomicInteger.decrementAndGet());    //减1再获取105
        System.out.println(atomicInteger);                      //105
        System.out.println(atomicInteger.getAndDecrement());    //先获取105，再减1
        System.out.println(atomicInteger);                      //104
    }
}

2.2. 数值比对及交换操作

compareAndSet操作将一个内存位置的内容与一个给定的值进行比较，只有当它们相同时，才会将该内存位置的内容修改为一个给定的新值。这个过程是以单个原子操作的方式完成的。

compareAndSet方法：如果当前值==预期值，则将值设置为给定的更新值。

boolean compareAndSet(int expect, int update)

expect是预期值

update是更新值

AtomicInteger compareAndSet() 方法的例子

import java.util.concurrent.atomic.AtomicInteger;
public class Main {
    public static void main(String[] args) {
        //初始值为100的atomic Integer
        AtomicInteger atomicInteger = new AtomicInteger(100);
        //当前值100 = 预期值100，所以设置atomicInteger=110
        boolean isSuccess = atomicInteger.compareAndSet(100,110);  
        System.out.println(isSuccess);      //输出结果为true表示操作成功
        //当前值110 = 预期值100？不相等，所以atomicInteger仍然等于110
        isSuccess = atomicInteger.compareAndSet(100,120);  
        System.out.println(isSuccess);      //输出结果为false表示操作失败
    }
}

3. 总结

AtomicInteger可以帮助我们在不使用synchronized同步锁的情况下，实现在多线程场景下int数值操作的线程安全，操作的原子性。并且使用AtomicInteger来实现int数值的原子操作，远比使用synchronized同步锁效率更高。

java.util.concurrent.atomic包不仅为我们提供了AtomicInteger

1. Utilisation de base d'AtomicInteger

Grâce au constructeur AtomicInteger ci-dessous, vous pouvez créer un objet AtomicInteger. La valeur initiale par défaut est 0. AtomicInteger fournit des méthodes get et set pour obtenir la valeur entière int sous-jacente et définir la valeur entière int #🎜🎜#rrreee#🎜🎜#Mais la méthode ci-dessus ne s'applique pas à AtomicInteger Ce n'est pas son contenu principal. Le contenu principal de AtomicInteger se reflète dans son atomicité, que nous présenterons ci-dessous. #🎜🎜#

2. Quand devez-vous utiliser AtomicInteger

#🎜🎜#Nous utilisons généralement AtomicInteger#🎜🎜##🎜🎜#Multi-threading dans les deux suivants scénarios Pour faire fonctionner un compteur dans un scénario concurrent, vous devez vous assurer de l'atomicité de l'opération du compteur. #🎜🎜##🎜🎜#Comparez les valeurs. Si la valeur donnée est égale à la valeur actuelle, mettez à jour la valeur et implémentez un algorithme non bloquant pour l'opération. #🎜🎜#

2.1. Scénario de compteur atomique

#🎜🎜# Utilisez AtomicInteger comme compteur AtomicInteger fournit plusieurs méthodes d'addition et de soustraction atomique. opérations. #🎜🎜##🎜🎜#Par exemple, pour obtenir une valeur à partir d'une carte, utilisez la méthode get(), qui est la première opération ; après avoir obtenu la valeur, ajoutez n à la valeur, qui est la deuxième opération ; le processus sera La valeur de l'opération d'addition est à nouveau mise dans la carte comme troisième opération. Ce qu'on appelle l'atomicité des opérations signifie que dans un scénario de concurrence multithread, les trois opérations ci-dessus sont atomiques, c'est-à-dire indivisibles. Il n'y aura aucune situation où le thread A obtient la valeur et le thread B obtient également la valeur en même temps. Les deux threads effectuent des opérations sur la valeur en même temps et la réinsèrent l'un après l'autre. Cette situation est pour AtomicInteger Non, les opérations <code>AtomicInteger sont thread-safe et indivisibles. #🎜🎜##🎜🎜#addAndGet()- Ajoutez la valeur donnée à la valeur actuelle et renvoyez la nouvelle valeur après l'ajout, garantissant l'atomicité de l'opération. #🎜🎜##🎜🎜#getAndAdd() - Ajoute la valeur donnée à la valeur actuelle et renvoie l'ancienne valeur, garantissant l'atomicité de l'opération. #🎜🎜##🎜🎜#incrementAndGet()- Augmente la valeur actuelle de 1 et renvoie la nouvelle valeur après l'augmentation. Elle est équivalente à l'opération ++i et garantit l'atomicité de l'opération. #🎜🎜##🎜🎜#getAndIncrement() - Augmente la valeur actuelle de 1 et renvoie l'ancienne valeur. Équivalent à l'opération ++i et assurant l'atomicité de l'opération. #🎜🎜##🎜🎜#decrementAndGet()- Soustraire 1 de la valeur actuelle et renvoyer la nouvelle valeur après soustraction, ce qui équivaut à l'opération i--, et Assurer l’atomicité des opérations. #🎜🎜##🎜🎜#getAndDecrement() - Soustrayez 1 de la valeur actuelle et renvoyez l'ancienne valeur. Elle est équivalente à l'opération --i et garantit l'atomicité de l'opération. #🎜🎜##🎜🎜#Ce qui suit est un exemple de la méthode d'opération atomique d'AtomicInteger#🎜🎜#rrreee

2.2 Opérations de comparaison et d'échange numériques

#🎜🎜#compareAndSet l'opération compare le contenu d'un l'emplacement mémoire avec une valeur donnée est comparé, et seulement s'ils sont identiques, le contenu de cet emplacement mémoire est modifié pour une nouvelle valeur donnée. Ce processus est réalisé comme une seule opération atomique. Méthode #🎜🎜##🎜🎜#compareAndSet : Si valeur actuelle == valeur attendue, définit la valeur sur la valeur mise à jour donnée. #🎜🎜#rrreee#🎜🎜#expect est la valeur attendue #🎜🎜##🎜🎜#update est la valeur mise à jour #🎜🎜##🎜🎜#AtomicInteger Exemple de méthode compareAndSet()#🎜🎜#rrreee

3. Résumé

#🎜🎜#AtomicInteger peut nous aider à implémenter des scénarios multithread sans utiliser de verrous de synchronisation synchronisés. Sécurité des threads de int numérique opérations et atomicité des opérations. Et utiliser AtomicInteger pour implémenter des opérations atomiques sur des valeurs int est bien plus efficace que d'utiliser des verrous de synchronisation synchronisés. #🎜🎜##🎜🎜#Le package java.util.concurrent.atomic nous fournit non seulement AtomicInteger, mais fournit également la classe d'opération atomique AtomicBoolean et l'entier long AtomicLong Classe d'opération atomique booléenne, classe d'opération atomique d'objet AtomicReference, classe d'opération atomique de tableau d'entiers AtomicIntegerArray, classe d'opération atomique de tableau d'entiers longs AtomicLongArray, classe d'opération atomique de tableau d'objets AtomicReferenceArray. #🎜🎜#

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!