Parallele Java-Programmierung: Analyse von Anwendungsbeispielen von AtomicInteger Atomic Integer von JUC Toolkit

Die AtomicInteger-Klasse speichert unten einen int-Wert und stellt Methoden zum Durchführen atomarer Operationen für den int-Wert bereit. AtomicInteger wurde in Java 1.5 als Teil des java.util.concurrent.atomic-Pakets eingeführt. 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. Grundlegende Verwendung von AtomicInteger

Mit dem AtomicInteger-Konstruktor unten können Sie ein AtomicInteger-Objekt erstellen, dessen Anfangswert standardmäßig 0 ist . AtomicInteger stellt Get- und Set-Methoden bereit, um den zugrunde liegenden int-Ganzzahlwert abzurufen und den int-Ganzzahlwert festzulegen🎜rrreee🎜Aber die obige Methode ist nicht der Kerninhalt von AtomicInteger , dem Kern Der Inhalt von AtomicInteger spiegelt sich in seiner Atomizität wider, die wir im Folgenden vorstellen werden. 🎜

2. Wann müssen Sie AtomicInteger verwenden

🎜Wir verwenden normalerweise AtomicInteger in den folgenden beiden Szenarien🎜🎜Um einen Zähler in einem Multithread-Parallelitätsszenario zu betreiben, benötigen Sie um die Gegenoperation Atomic sicherzustellen. 🎜🎜Werte vergleichen. Wenn der angegebene Wert mit dem aktuellen Wert übereinstimmt, aktualisieren Sie den Wert und implementieren Sie einen nicht blockierenden Algorithmus für den Vorgang. 🎜

2.1. Atomares Zählerszenario

🎜Verwenden Sie AtomicInteger als Zähler. AtomicInteger bietet verschiedene Methoden zur Durchführung atomarer Additions- und Subtraktionsoperationen. 🎜🎜Um beispielsweise einen Wert aus einer Karte abzurufen, verwenden Sie die Methode get(), die die erste Operation ist, nachdem Sie den Wert erhalten haben. Fügen Sie n zum Wert hinzu, was die zweite Operation ist, und fügen Sie den Wert erneut hinzu Das Einfügen in die Karte ist die dritte Operation. Die sogenannte Atomizität von Operationen bedeutet, dass in einem Multithread-Parallelitätsszenario die oben genannten drei Operationen atomar, also unteilbar, sind. Es wird keine Situation geben, in der Thread A den Wert erhält und Thread B gleichzeitig auch den Wert erhält. Die beiden Threads führen gleichzeitig Operationen für den Wert durch und fügen ihn nacheinander erneut ein. Diese Situation gilt für AtomicInteger Nein, AtomicInteger-Operationen sind threadsicher und unteilbar. 🎜🎜addAndGet()- Addieren Sie den angegebenen Wert zum aktuellen Wert und geben Sie nach der Addition den neuen Wert zurück, um die Atomizität der Operation sicherzustellen. 🎜🎜getAndAdd() – Addieren Sie den angegebenen Wert zum aktuellen Wert und geben Sie den alten Wert zurück, um die Atomizität der Operation sicherzustellen. 🎜🎜incrementAndGet()- Erhöhen Sie den aktuellen Wert um 1 und geben Sie den neuen Wert nach der Erhöhung zurück. Es entspricht der Operation ++i und garantiert die Atomizität der Operation. 🎜🎜getAndIncrement() – Erhöhen Sie den aktuellen Wert um 1 und geben Sie den alten Wert zurück. Entspricht der Operation ++i und stellt die Atomizität der Operation sicher. 🎜🎜decrementAndGet()- Subtrahieren Sie 1 vom aktuellen Wert und geben Sie den neuen Wert nach der Subtraktion zurück, was der Operation i-- entspricht und die Atomizität der Operation gewährleistet . 🎜🎜getAndDecrement()- Subtrahieren Sie 1 vom aktuellen Wert und geben Sie den alten Wert zurück. Es entspricht der Operation --i und garantiert die Atomizität der Operation. 🎜🎜Das Folgende ist ein Beispiel für die atomare Operationsmethode von AtomicInteger🎜rrreee

2.2. Numerische Vergleichs- und Austauschoperationen

🎜compareAndSet-Operation vergleicht den Inhalt eines Speicherorts nur dann mit einem bestimmten Wert, wenn er mit At übereinstimmt Gleichzeitig wird der Inhalt des Speicherorts auf einen bestimmten neuen Wert geändert. Dieser Prozess wird als einzelne atomare Operation abgeschlossen. 🎜🎜compareAndSet-Methode: Wenn aktueller Wert == erwarteter Wert, wird der Wert auf den angegebenen aktualisierten Wert gesetzt. 🎜rrreee🎜expect ist der erwartete Wert 🎜🎜update ist der aktualisierte Wert 🎜🎜Ein Beispiel für die AtomicInteger-compareAndSet()-Methode🎜rrreee

3. h3>🎜AtomicInteger kann uns dabei helfen, Thread-Sicherheit und Atomizität von int-numerischen Operationen in Multi-Thread-Szenarien zu erreichen, ohne synchronisierte Synchronisationssperren zu verwenden. Und die Verwendung von AtomicInteger zur Implementierung atomarer Operationen für int-Werte ist weitaus effizienter als die Verwendung synchronisierter Synchronisationssperren. 🎜🎜java.util.concurrent.atomic-Paket stellt uns nicht nur AtomicInteger zur Verfügung, sondern auch die Klasse AtomicBoolean Boolean für atomare Operationen, die Klasse AtomicLong long integer Boolean für atomare Operationen und AtomicReference Atomare Operationsklasse des Objekts, atomare Operationsklasse des Ganzzahlarrays AtomicIntegerArray, atomare Operationsklasse des AtomicLongArray-Long-Integer-Arrays, atomare Operationsklasse des Objektarrays AtomicReferenceArray. 🎜

Das obige ist der detaillierte Inhalt vonParallele Java-Programmierung: Analyse von Anwendungsbeispielen von AtomicInteger Atomic Integer von JUC Toolkit. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!