Einführung
Java stellt das Java.util.Concurrent.atomic-Paket seit JDK1.5 zur Verfügung, das Programmierern ermöglicht, atomare Operationen ohne Schlösser in einer Umgebung mit mehreren Threads auszuführen. Die zugrunde liegende Schicht von Atomvariablen verwendet die vom Prozessor bereitgestellten atomaren Anweisungen, aber verschiedene CPU -Architekturen können unterschiedliche Atomanweisungen liefern und möglicherweise auch eine Form der internen Sperre erfordern. Diese Methode kann daher nicht unbedingt sicherstellen, dass der Faden nicht blockiert wird.
Atomic -Paket Einführung
Es gibt 12 Klassen im Atompaket, und vier Atom -Update -Methoden sind: Basistypen von Atom -Update, Atom -Update -Arrays, Atom -Update -Referenzen und Atom -Update -Felder. Die Klassen im Atompaket sind im Grunde genommen mit Unsicherheit umwickelte Klassen.
Atomic Update Grundtypklasse
Für die Aktualisierung von Grundtypen durch Atomic -Methoden enthält das Atomic -Paket die folgenden drei Klassen:
Atomicboolean: Atomic Updates Der Boolesche Typ.
Atomicinteger: Atomic Update Integer.
Atomiclong: Atomic Update Long Ganzzahl.
Häufige Methoden der Atomicinder sind wie folgt:
int addandget (int delta): Fügt den Wert des Wertes in der Instanz (Wert in Atomicinger) auf atomare Weise hinzu und gibt das Ergebnis zurück
boolean vergleicheSet (int erwart, int update): Wenn der Eingabewert dem erwarteten Wert entspricht, setzen Sie den Wert auf den Eingabewert atomisch fest.
int getandincrement (): Fügt den aktuellen Wert zu 1 atomisch hinzu. Hinweis: Der zurückgegebene Wert hier ist der Wert vor dem AutoIncrement.
void lazyset (int newValue): Es wird schließlich auf NewValue eingestellt. Nachdem ich Lazyset zum Einstellen des Werts verwendet habe, können andere Threads möglicherweise weiterhin den alten Wert int und GetAndSet (int NewValue) lesen: Es wird auf atomarer Weise auf den Wert von NewValue eingestellt und den alten Wert zurückgibt.
Der Atomicinteger -Beispielcode lautet wie folgt:
import Java.util.concurrent
Ausgabe
12
Dessert nach dem Abendessen
Das Atompaket bietet drei grundlegende Arten von Atom -Updates, aber Java -Grundtypen umfassen Zeichen, Float und Double. Die Frage ist also, wie Sie andere grundlegende Arten von Atomen aktualisieren können. Die Klassen im Atompaket werden im Grunde genommen mit Unsicherheit implementiert. Werfen wir einen Blick auf den Quellcode Unsicheres. Wir fanden heraus, dass Unsicherheit nur drei CAS -Methoden, VergleicheSwapObject, VergleicheSwapint und VergleicheSwaplong liefert. Schauen Sie sich dann den Atomicboolen -Quellcode an. Wir haben festgestellt, dass es zuerst Boolesche in eine Ganzzahl umwandelt und dann VergleicheAndswapint für CAS verwendet. Daher kann das Double des Atom -Updates auch mit ähnlichen Ideen implementiert werden.
Atomic Update Array Class
Das Atomic -Paket enthält die folgenden drei Klassen:
AtomicIntegerArray: Atomar aktualisiert Elemente in einem Ganzzahl -Array.
Atomiclongarray: Atomic Updates Elements in langen Arrays.
AtomicReferencearray: Atom -Updates Elemente im Referenztyp -Array.
Die Atomicintegerarray -Klasse bietet hauptsächlich Atomic, um die Ganzzahlen im Array zu aktualisieren. Die häufig verwendeten Methoden sind wie folgt
int addandget (int i, int delta): Fügt den Eingangswert atomisch zum Elementindex I im Array hinzu.
boolean vergleicheSet (int i, int erwart, int update): Wenn der aktuelle Wert dem erwarteten Wert entspricht, ist das Element an der Array -Position I atomisch auf den Aktualisierungswert festgelegt.
Der Beispielcode lautet wie folgt:
öffentliche Klasse AtomicintegerArrayTest {static int [] value = new int [] {1, 2}; statische Atomicintegerarray ai = new Atomicintegerarray (Wert); public static void main (String [] args) {ai.getandset (0, 0, 0, 3); System.out.println (ai.get (0)); System.out.println (Wert [0]);}}Ausgabe
31
Was Sie in der AtomicIntegerArray -Klasse beachten müssen, ist, dass der Array -Wert über die Konstruktor -Methode übergeben wird. Anschließend kopiert AtomicIntegerArray das aktuelle Array A Kopie. Wenn AtomicintegerArray die internen Arrayelemente modifiert, wird sich dies nicht auf das übergebene Array auswirken.
Referenztyp von Atomic Update
AtomicInteger, ein Grundtyp, kann nur eine Variable aktualisieren. Wenn Sie atomisch mehrere Variablen aktualisieren möchten, müssen Sie dieses Atom verwenden, um die vom Referenztyp bereitgestellte Klasse zu aktualisieren. Das Atomic -Paket enthält die folgenden drei Klassen:
Atomicreference: Atomic Aktualisiert den Referenztyp.
AtomicreferencefieldUpdater: Atom -Updates Felder im Referenztyp.
AtomicmarkableReference: Atomic Aktualisiert den Referenztyp mit Marker -Bits. Sie können einen booleschen Tag -Bit und einen Referenztyp atomisch aktualisieren. Die Konstruktionsmethode ist AtomicmarkableReference (V initialRef, boolean initialmark)
Der Code für die Verwendung von Atomicreference lautet wie folgt:
public class atomicreferencetest {public static atomicreference <CremicUcuSerref = new Atomicreference </user> <Benutzer> (). 17); atomicuserref.comPareAnDSet (Benutzer, UpdateUser); System.out.println (atomicuserref.get (). GetName ()); system.out.println (atomicuserRef.get (). Old;} public String getName () {return name;} public int getold () {return Old;}}}Ausgabe
Shinichi17
Atomic Update Feldklasse
Wenn wir in einer bestimmten Klasse nur ein bestimmtes Feld benötigen, müssen wir Atomic verwenden, um die Feldklasse zu aktualisieren. Das Atomic -Paket enthält die folgenden drei Klassen:
AtomicIntegerfieldupdater: Ein Updater für Fields, die atomische Ganzzahlen aktualisieren.
Atomiclongfieldupdater: Ein Updater für Atomic -Updates Lange Ganzzahlfelder.
AtomicStampedReference: Atomic Aktualisiert den Referenztyp mit einer Versionsnummer. Diese Klasse assoziiert Ganzzahlwerte mit Referenzen und kann für Atomic mehr Daten und Versionsnummern verwendet werden, die die ABA -Probleme lösen können, die bei der Verwendung von CAS für Atom -Updates auftreten können.
Atomic -Update -Feldklassen sind abstrakte Klassen, und jedes Mal, wenn sie verwendet werden, müssen sie die statische Methode für Newupdater verwenden, um einen Updater zu erstellen. Der öffentliche volatile Modifikator muss für Felder der Atom -Update -Klasse verwendet werden.
Der erste Schritt besteht darin, dass Sie, wenn Sie die Atomic Update -Feldklassen abstrakter Klassen sind, jedes Mal, wenn Sie die statische Methode AtomicIntegerfieldUpdater.Newupdater verwenden, einen Updater erstellen müssen und die Klassen und Eigenschaften festlegen müssen, die Sie aktualisieren möchten. Der zweite Schritt besteht darin, die Felder (Eigenschaften) der Klasse zu aktualisieren, die den öffentlichen flüchtigen Modifikator (private volatile int alt) verwenden müssen.
Der Beispielcode von Atomicintegerfieldupdater lautet wie folgt:
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; public user (String name, int alt) {this.name = name;Ausgabe
1011
Zusammenfassen
Der oben genannte ist der gesamte Inhalt dieses Artikels über die Einführung und Verwendung des Java-Multi-Thread-Atompakets. Ich hoffe, es wird für alle hilfreich sein. Interessierte Freunde können weiterhin auf diese Seite verweisen:
Einführung in die Methode zum Schreiben von Produktionsverbrauchermodell unter verschiedenen Bedingungen in Java Multithreading
Java Multithread -Programmierung Synchronizer Zukunft und Futuretask -Analyse- und Codebeispiele
Eine detaillierte Erklärung des Java-Multi-Thread-Display-Schloss und der integrierten Schloss
Wenn es Mängel gibt, hinterlassen Sie bitte eine Nachricht, um darauf hinzuweisen.