Atómica en JavaScript

Atomics: Atomics es un objeto de JavaScript que proporciona tareas atómicas para proceder como estrategias estáticas. Al igual que las estrategias para el objeto Math, las técnicas y propiedades de Atomics también son estáticas. Los elementos atómicos se utilizan con objetos SharedArrayBuffer. Las actividades de Atomic se introducen en un módulo de Atomics. A diferencia de otros artículos de todo el mundo, Atomics no es un constructor. Atomics no se puede utilizar con otro administrador o se puede invocar como una capacidad.

Operaciones atómicas:   Las operaciones atómicas no son continuas.. Múltiples subprocesos pueden leer y escribir datos en la memoria cuando se comparte la memoria. Hay una pérdida de datos si alguno de los datos ha cambiado Las operaciones atómicas aseguran que los datos se escriben y se leen con precisión según los valores predichos. No hay forma de cambiar la información existente hasta que se complete la operación actual y comiencen las operaciones atómicas.

Métodos: 

• Atomics.add(): agrega el valor proporcionado al valor actual en el índice de array especificado. Devuelve el valor del índice anterior.
• Atomics.and(): el valor AND se calcula bit a bit en el índice de la array especificada con el valor proporcionado. Devuelve el valor anterior de ese índice.
• Atomics.exchange(): especifica un valor en el índice de array especificado. Se devuelve el valor antiguo.
• Atomics.compareExchange(): especifica el valor en el índice de array especificado si el valor es el mismo. Vuelve el valor antiguo.
• Atomics.isLockFree(size): Optimización primitiva para determinar si se van a utilizar bloqueos u operaciones atómicas. Devuelve verdadero si se lleva a cabo una operación atómica de hardware en las arrays del tamaño de elemento dado (a diferencia de un bloqueo).
• Atomics.load(): el valor vuelve al índice de array especificado.
• Atomics.or(): Bitwise OR calcula el valor con el valor dado en el índice de array especificado. Devuelve el valor del índice anterior.
• Atomics.notify(): notifica a los agentes que esperan el índice de array especificado. Devuelve el número notificado de agentes.
• Atomics.sub(): elimina un valor en el índice de array especificado. Devuelve el valor del índice anterior.
• Atomics.store(): guarda un valor en el índice de array especificado. Devuelve valor.
• Atomics.wait(): Verifica que el índice de array especificado aún tenga un valor y que los tiempos de espera o de espera estén inactivos. Devuelve «ok», «no es lo mismo» o «tiempo de espera». Si el agente que llama no puede esperar, lanza una excepción a un error.
• Atomics.xor(): Calcule un XOR bit a bit con el valor dado en el índice de array dado. Devuelve el valor del índice anterior.

Ejemplo 1:

var buffer = new 
// create a SharedArrayBuffer
SharedArrayBuffer(50); 
var a = new Uint8Array(buffer);
// Initialising element at zeroth position of array with 9 
a[0] = 9;
console.log(Atomics.load(a, 0)); 
// Displaying the return value of the Atomics.store() method
console.log(Atomics.store(a, 0, 3)); 
// Displaying the updated SharedArrayBuffer 
console.log(Atomics.load(a, 0));

Producción:

933

Ejemplo 2:

const buffer = new SharedArrayBuffer(2048);
  
const ta = new Uint8Array(buffer);
  
ta[0]; // 0
  
ta[0] = 5; // 5
  
Atomics.add(ta, 0, 12);   // 5
  
Atomics.load(ta, 0);      // 17
  
Atomics.and(ta, 0, 1); // 17
  
Atomics.load(ta, 0); // 1
  
Atomics.exchange(ta, 0, 12); // 1
  
Atomics.load(ta, 0); // 12
  
Atomics.compareExchange(ta, 0, 5, 12); // 1
  
Atomics.load(ta, 0); // 1
  
Atomics.isLockFree(1); // true
  
Atomics.isLockFree(2); // true
  
Atomics.or(ta, 0, 1); // 12
  
Atomics.load(ta, 0);  // 13
  
Atomics.store(ta, 0, 12); // 12
  
Atomics.sub(ta, 0, 2); // 12
  
Atomics.load(ta, 0); // 10
  
Atomics.xor(ta, 0, 1); // 10
  
Atomics.load(ta, 0); // 11

Producción:

5
17
17
1
1
12
1
1
True
True
13
13
12
12
10
10