Atomics.compareExchange() 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.compareExchange()

• Entre las operaciones atómicas, hay un método incorporado Atomics.compareExchange() que se usa para intercambiar un valor en una posición específica de una array si el parámetro pasado es igual al valor anterior que reside en la array.
• La operación Atomics.compareExchange( ) en JavaScript intercambia el valor en la array solo si el parámetro pasado es igual al valor anterior en esa posición.
• La operación Atomics.compareExchange( ) devuelve el valor anterior que reside en esa posición de la array, ya sea que sea igual o no al valor esperado.
• No se puede realizar ninguna otra operación de escritura hasta que se vuelva a escribir el valor modificado.

Sintaxis:

Atomics.compareExchange(typedArray, index, expectedValue, replacementValue)

Parámetros utilizados:

• typedarray: es la array de tipo entero compartido que desea modificar.
• index: Es la posición en el typedArray desde donde desea intercambiar un valor.
• valoresperado: Es el número para el cual se debe verificar la igualdad.
• replaceValue : Es el número a intercambiar.

Valor devuelto:

• Atomics.compareExchange() devuelve el valor anterior en la posición dada (typedArray[index]).

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

Ejemplos:

Input : arr[0] = 9;
        Atomics.compareExchange(arr, 0, 9, 5);
Output : 5

Input : arr[0] = 3; 
        Atomics.compareExchange(arr, 0, 3, 6);
Output : 6

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 return value of the Atomics.compareExchange() method 
console.log(Atomics.compareExchange(arr, 0, 9, 5));
  
// Displaying the updated SharedArrayBuffer 
console.log(Atomics.load(arr, 0));
</script>

PRODUCCIÓN :

9
5

Código 2:

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

PRODUCCIÓN :

3
6

Solicitud:

• Cada vez que queremos intercambiar (solo si el parámetro pasado es igual al valor) un valor en una posición específica de una array y también queremos devolver el valor anterior que estaba en esa posición de la array, usamos la operación Atomics.compareExchange() en JavaScript.

  Veamos un programa JavaScript:

  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.compareExchange() method  console.log(Atomics.compareExchange(myarray, 0, 40, 20));    // Displaying the updated SharedArrayBuffer  console.log(Atomics.load(myarray, 0)); </script>

  Producción :

  40
  20
  

Excepciones:

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

Diferencia entre Atomics.compareExchange y Atomics.exchange
Como leemos, la operación Atomics.compareExchange() en JavaScript intercambia el valor en la array solo si el parámetro pasado es igual al valor anterior en esa posición, mientras que la operación Atomics.exchange() en JavaScript intercambia y almacena un valor dado en una posición dada en la array sin compararlo con el valor anterior que reside en esa posición de la array.
Ambas operaciones devuelven el valor anterior que estaba presente en la posición especificada.

Navegador compatible:

• Google Chrome
• Borde de Microsoft
• Firefox