introducción
Java proporciona el paquete java.util.concurrent.atomic desde JDK1.5, que facilita a los programadores a realizar operaciones atómicas sin bloqueos en un entorno múltiple. La capa subyacente de variables atómicas utiliza instrucciones atómicas proporcionadas por el procesador, pero diferentes arquitecturas de CPU pueden proporcionar diferentes instrucciones atómicas, y también puede requerir alguna forma de bloqueo interno, por lo que este método no puede garantizar absolutamente que el hilo no esté bloqueado.
Introducción al paquete atómico
Hay 12 clases en el paquete atómico, y cuatro métodos de actualización atómica son: tipos básicos de actualización atómica, matrices de actualización atómica, referencias de actualización atómica y campos de actualización atómica. Las clases en el paquete atómico son básicamente clases envueltas implementadas usando inseguros.
Clase de tipo Básico de actualización atómica
Para actualizar los tipos básicos a través de métodos atómicos, el paquete atómico proporciona las siguientes tres clases:
Atomicboolean: Atomic actualiza el tipo booleano.
AtomicInteger: Atomic Update Integer.
AtomicLong: Atomic Update Long entero.
Los métodos comunes de atomicinteger son los siguientes:
int addandget (int delta): agrega el valor de entrada al valor en la instancia (valor en atomicInteger) de manera atómica y devuelve el resultado
Comparación booleana (int espere, int actualización): si el valor de entrada es igual al valor esperado, establezca el valor en el valor de entrada atómicamente.
int getandincrement (): agrega el valor actual a 1 atómicamente. Nota: El valor devuelto aquí es el valor antes del autoincremento.
Void Lazyset (int NewValue): eventualmente se establecerá en NewValue. Después de usar LazySet para establecer el valor, otros subprocesos aún pueden leer el valor anterior int getAndset (int NewValue): se establece en el valor de NewValue de manera atómica y devuelve el valor anterior.
El código de ejemplo de AtomicInteger es el siguiente:
import java.util.concurrent.atomic.atomicInteger; public class AtomicInteGertest {static atomicInTEGER ai = new AtomiCInteger (1); public static void main (string [] system.out.println (ai.getandIrcrement ()); system.out.println (ai.get ();});});});}Producción
12
Postre después de la cena
El paquete atómico proporciona tres tipos básicos de actualizaciones atómicas, pero los tipos básicos de Java incluyen char, flotante y doble. Entonces, la pregunta es, ¿cómo actualizar otros tipos básicos de átomos? Las clases en el paquete atómico se implementan básicamente utilizando inseguro. Echemos un vistazo al código fuente de inseguro. Descubrimos que InsafE solo proporciona tres métodos CAS, comparación, wapobject, comparación y comparación y comparación. Luego mire el código fuente del atomicboole. Descubrimos que primero convierte booleano en un entero, y luego usa comparación con comparación para CAS, por lo que Atomic Update Double también se puede implementar utilizando ideas similares.
Clase de matriz de actualizaciones atómicas
El paquete atómico proporciona las siguientes tres clases:
AtomicIntegerArray: actualiza atómicamente elementos en una matriz entera.
AtomicLongarrray: Atomic Actualates Elementos en matrices largas.
AtomicreferencearRay: Atomic Actualations Elementos en la matriz de tipo de referencia.
La clase AtomicInteGerArray proporciona principalmente Atomic para actualizar los enteros en la matriz. Los métodos de uso común son los siguientes
int addandget (int i, int delta): agrega el valor de entrada atómicamente al índice del elemento i en la matriz.
Boolean CompareandSet (int i, int espere, int actualización): si el valor actual es igual al valor esperado, el elemento en la posición de la matriz I se establece atómicamente en el valor de actualización.
El código de ejemplo es el siguiente:
Clase pública AtomiCintegerArrayTest {static int [] value = new int [] {1, 2}; static atomicIntegeroRray ai = new AtomicIntegerArray (valor); public static void main (string [] args) {ai.getandset (0, 0, 0, 0, 3); System.out.println (ai.get (0)); system.out.println (valor [0]);}}Producción
31
Lo que debe tener en cuenta en la clase AtomicInTegerArray es que el valor de la matriz se pasa a través del método del constructor, y luego AtomiCInteGeroRray copiará la matriz actual una copia, por lo que cuando AtomiCiNTEGERArray modifica los elementos de matriz internos, no afectará la matriz aprobada.
Tipo de referencia de actualización atómica
AtomicInteger, que es un tipo básico, solo puede actualizar una variable. Si desea actualizar múltiples variables atómicamente, debe usar este átomo para actualizar la clase proporcionada por el tipo de referencia. El paquete atómico proporciona las siguientes tres clases:
Atomicreference: Atomic actualiza el tipo de referencia.
AtomicreferenceFieldUpdater: Atomic Actualations Fields en el tipo de referencia.
AtomicMarkableReference: Atomic actualiza el tipo de referencia con bits de marcador. Puede actualizar atómicamente un bit de etiqueta de tipo booleano y un tipo de referencia. El método de construcción es AtomicMarkableReference (v InitialRef, Boolean Initialmark)
El código para usar atomicreference es el siguiente:
public class AtomicreferenceTest {public static atomicreference <serer> AtomicuserRef = new Atomicreference </serem> <serer> (); public static void main (string [] args) {user user = new user ("conan", 15); atomicuserref.set (user); user UpdateUser = new User ("shinichi", 17); AtomicusereT (user) (user); usuarios de usuarios = "SHINICHI", 17); ATMICUCEMEFET (user) (user); usuarios de usuarios = "SHINICHI", 17); AtomicuserEtet (user); user (user); usuarios de usuarios = "SHINICHI", 17); ATMICUCESEFET (user); updateUser); system.out.println (atomicUserRef.get (). getOld () {return viejo;}}}Producción
Shinichi17
Clase de campo de actualización atómica
Si solo necesitamos un campo determinado en una determinada clase, debemos usar Atomic para actualizar la clase de campo. El paquete atómico proporciona las siguientes tres clases:
AtomicIntegerFieldUpdater: un actualizador para campos que actualizan atómicamente enteros.
AtomicLongFieldUpdater: un actualizador de actualizaciones atómicas largos campos enteros.
AtomicStampedReference: Atomic actualiza el tipo de referencia con un número de versión. Esta clase asocia los valores enteros con referencias y puede usarse para más datos atómicos y números de versión, lo que puede resolver los problemas de ABA que pueden surgir al usar CAS para actualizaciones atómicas.
Las clases de campo de actualización atómica son clases abstractas, y cada vez que se usan, deben usar el método estático NewUpdater para crear un actualizador. El modificador volátil público debe usarse para campos de la clase Atomic Update.
El primer paso es que debido a que las clases de campo de actualización atómica son clases abstractas, cada vez que usa el método estático AtomicIntegerFieldupdater.newupdater, debe crear un actualizador y debe establecer las clases y propiedades que desea actualizar. El segundo paso es actualizar los campos (propiedades) de la clase debe usar el modificador volátil público (privado volátiles int viejos)
El código de ejemplo de AtomicInTEGFieldUpdater es el siguiente:
Clase pública AtomicInTegerFieldupdaterTest {private static atomicIntegEgerfieldupdater <serem> a = AtomicInTegerFieldupdater.newupdater (user.class, "antiguo"); public static void main (string [] args) {user conan = nuevo usuario ("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 (name de cadena, int antiguo) {this.name = name; this.old = Old;} public string getName () {return name;}Producción
1011
Resumir
Lo anterior es todo el contenido de este artículo sobre la introducción y el uso del paquete atómico multiproceso Java. Espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a este sitio:
Introducción al método de redacción del modelo de consumidor de producción en diferentes condiciones en Java múltiple liquidación
Java Synchronizer Synchronizer Future y Futuretask Analizando y ejemplos de código
Una explicación detallada del bloqueo de visualización de múltiples subprocesos de Java y el bloqueo incorporado
Si hay alguna deficiencia, deje un mensaje para señalarlo.