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开始引入。
通过下文的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
核心内容体现在它的原子性,我们下文介绍。
我们通常在以下的两种场景下使用AtomicInteger
多线程并发场景下操作一个计数器,需要保证计数器操作的原子性。
进行数值比较,如果给定值与当前值相等,进行数值的更新操作,并实现操作的非阻塞算法。
把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 } }
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表示操作失败 } }
AtomicInteger
可以帮助我们在不使用synchronized同步锁的情况下,实现在多线程场景下int数值操作的线程安全,操作的原子性。并且使用AtomicInteger
来实现int数值的原子操作,远比使用synchronized同步锁效率更高。
java.util.concurrent.atomic
包不仅为我们提供了AtomicInteger
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. #🎜🎜#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. #🎜🎜#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 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#🎜🎜#rrreeeexpect
est la valeur attendue #🎜🎜##🎜🎜#update
est la valeur mise à jour #🎜🎜##🎜🎜#AtomicInteger Exemple de méthode compareAndSet()#🎜🎜#rrreeeAtomicInteger
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!