Atomics.store() en JavaScript

¿Qué es la atómica?

• Atomics es un objeto en JavaScript que brinda la capacidad de realizar operaciones atómicas como métodos estáticos.
• Al igual que el objeto Math en JavaScript, todas las propiedades y métodos de Atomics también son estáticos.
• Los elementos atómicos se utilizan con objetos SharedArrayBuffer (búfer genérico de datos binarios de longitud fija).
• Los átomos no son constructores como otros objetos globales.
• Atomics no se puede usar con un nuevo operador o se puede invocar como una función.

Operaciones atómicas en JavaScript
Múltiples subprocesos pueden leer y escribir los mismos datos en la memoria cuando hay memoria compartida. Para garantizar que los valores predichos se escriban y lean con precisión, no se puede iniciar otra operación hasta que finalice la actual. Las operaciones atómicas tampoco se pueden interrumpir.

Método Atomics.store()

• Entre las operaciones atómicas, hay una operación incorporada Atomics.store() en JavaScript que se usa para almacenar un valor específico en una posición específica de una array.
• La operación Atomics.store() devuelve el valor que se ha almacenado.
• El tipo enterodarray, el índice y el valor se pasan como argumento a la función y devuelve el valor que se ha almacenado en la array respectiva.

Sintaxis:

Atomics.store(typedArray, index, value)

Parámetros utilizados:

1. typedarray: es la array de tipo entero compartido que desea modificar.
2. índice: Es la posición en el typedArray desde donde desea almacenar un valor.
3. value : Es el número que desea almacenar.

Valor devuelto:
Atomics.store() devuelve el valor que se ha almacenado.

A continuación se proporcionan ejemplos de la función anterior.

Ejemplos:

Input : arr[0] = 9;
        Atomics.store(arr, 0, 3);
Output : 3

Input : arr[0] = 3; 
        Atomics.store(arr, 0, 2);
Output : 2

Los códigos para la función anterior se proporcionan a continuación.

Código 1:

<script>
// creating a SharedArrayBuffer 
var buf = new SharedArrayBuffer(25);
var arr = new Uint8Array(buf);
  
// Initialising element at zeroth position of array with 9
arr[0] = 9;
  
// Displaying the SharedArrayBuffer 
console.log(Atomics.load(arr, 0));
  
// Displaying the return value of the Atomics.store() method 
console.log(Atomics.store(arr, 0, 3));
  
// Displaying the updated SharedArrayBuffer 
console.log(Atomics.load(arr, 0));
</script>

PRODUCCIÓN :

9
3
3

Código 2:

<script>
// creating a SharedArrayBuffer
var buf = new SharedArrayBuffer(25);
var arr = new Uint8Array(buf);
  
// Initialising element at zeroth position of array with 3
arr[0] = 3;
  
// Displaying the SharedArrayBuffer
console.log(Atomics.load(arr, 0));
  
// Displaying the return value of the Atomics.store() method
console.log(Atomics.store(arr, 0, 2));
  
// Displaying the updated SharedArrayBuffer 
console.log(Atomics.load(arr, 0));
</script>

PRODUCCIÓN :

3
2
2

Aplicación:
siempre que queramos almacenar un valor en una posición específica de una array y también queramos devolver el mismo valor, usamos la operación Atomics.store() en JavaScript.

Veamos un programa JavaScript:

<script>
// creating a SharedArrayBuffer 
var mybuffer = new SharedArrayBuffer(25);
var myarray = new Uint8Array(mybuffer);
  
// Initialising the element at zeroth position of array
myarray[0] = 40;
  
// Displaying the return value of the Atomics.store() method
console.log(Atomics.store(myarray, 0, 20));
  
// Displaying the updated SharedArrayBuffer 
console.log(Atomics.load(myarray, 0));
</script>

Producción :

20
20

Excepciones:

• Si typedArray no es uno de los tipos de enteros permitidos, la operación Atomics.store( ) genera un TypeError.
• Si typedArray no es una array tipificada compartida, la operación Atomics.store() genera un TypeError.
• Si el índice utilizado como argumento para la operación Atomics.store() está fuera del límite en typedArray, entonces la operación Atomics.store() arroja un RangeError.