Atomics - Guía rápida

Atomística

Atomics es un objeto en JavaScript que proporciona operaciones atómicas que se realizarán como métodos estáticos. Al igual que los métodos del objeto Math, los métodos y propiedades de Atomics también son estáticos. Los átomos se utilizan con objetos SharedArrayBuffer.

Las operaciones atómicas se instalan en un módulo atómico. A diferencia de otros objetos globales, Atomics no es un constructor. Atomics no se puede usar con un operador nuevo o se puede invocar como una función.

Operaciones atómicas

Las operaciones atómicas son ininterrumpidas.

Cuando se comparte la memoria, varios subprocesos pueden leer o escribir datos existentes en la memoria. Por tanto, si se modifica algún dato, habrá una pérdida de datos. Las operaciones atómicas se aseguran de que los valores predichos (datos) se escriban y lean con precisión. Las operaciones atómicas no se iniciarán hasta que finalice la operación actual, por lo que no hay forma de cambiar los datos existentes.

Ejemplo

A continuación se muestra el código que demuestra el uso de JavaScript Atomics Operation:

<!DOCTYPE html>
<html lang="en">
   <head>
      <meta charset="UTF-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
      <title>Atomics Example</title>
      <style>
         .result {
            font-size: 20px;
            border: 1px solid black;
         }
      </style>
   </head>
   <body onLoad="operate();">
      <h1>JavaScript Atomics Properties</h1>
      <div class="result"></div>
      <p>Atomics.add(arr, 0, 2)</p>
      <p>Atomics.load(arr, 0)</p>
      <script>
         function operate(){
            let container = document.querySelector(".result");
            // create a SharedArrayBuffer
            var buffer = new SharedArrayBuffer(25);
            var arr = new Uint8Array(buffer);
            // Initialise element at zeroth position of array with 6
            arr[0] = 6;
            container.innerHTML = Atomics.add(arr, 0, 2) + '<br/>' + Atomics.load(arr, 0);
         }
      </script>
   </body>
</html>

Salida

Verifique el resultado.

Atomística

Atomics es un objeto en JavaScript que proporciona operaciones atómicas que se realizarán como métodos estáticos. Al igual que los métodos del objeto Math, los métodos y propiedades de Atomics también son estáticos. Los átomos se utilizan con objetos SharedArrayBuffer.

Las operaciones atómicas se instalan en un módulo atómico. A diferencia de otros objetos globales, Atomics no es un constructor. Atomics no se puede usar con un operador nuevo o se puede invocar como una función.

Operaciones atómicas

Las operaciones atómicas son ininterrumpidas.

Cuando se comparte la memoria, varios subprocesos pueden leer o escribir datos existentes en la memoria. Por tanto, si se modifica algún dato, habrá una pérdida de datos. Las operaciones atómicas se aseguran de que los valores predichos (datos) se escriban y lean con precisión. Las operaciones atómicas no se iniciarán hasta que finalice la operación actual, por lo que no hay forma de cambiar los datos existentes.

Ejemplo

A continuación se muestra el código que demuestra el uso de JavaScript Atomics Operation:

<!DOCTYPE html>
<html lang="en">
   <head>
      <meta charset="UTF-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
      <title>Atomics Example</title>
      <style>
         .result {
            font-size: 20px;
            border: 1px solid black;
         }
      </style>
   </head>
   <body onLoad="operate();">
      <h1>JavaScript Atomics Properties</h1>
      <div class="result"></div>
      <p>Atomics.add(arr, 0, 2)</p>
      <p>Atomics.load(arr, 0)</p>
      <script>
         function operate(){
            let container = document.querySelector(".result");
            // create a SharedArrayBuffer
            var buffer = new SharedArrayBuffer(25);
            var arr = new Uint8Array(buffer);
            // Initialise element at zeroth position of array with 6
            arr[0] = 6;
            container.innerHTML = Atomics.add(arr, 0, 2) + '<br/>' + Atomics.load(arr, 0);
         }
      </script>
   </body>
</html>

Salida

Verifique el resultado.

addEl método agrega un valor proporcionado en una posición determinada en la matriz. Devuelve el valor anterior en esa posición. Esta operación atómica garantiza que no se pueda realizar ninguna otra escritura hasta que se vuelva a escribir el valor modificado.

Sintaxis

Atomics.add(typedArray, index, value)

Parámetros

  • typedArray es la matriz de tipo entero.

  • index es posición en typedarray.

  • value para ser agregado.

Regreso

Devuelve el valor antiguo en la posición dada.

Excepciones

  • TypeError en caso de que la matriz pasada no sea una matriz de tipo entero.

  • RangeError si el índice pasado está fuera del límite en la matriz con tipo.

Ejemplo

A continuación se muestra el código para implementar JavaScript Atomics:

<!DOCTYPE html>
<html lang="en">
   <head>
      <meta charset="UTF-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
      <title>Atomics Example</title>
      <style>
         .result {
            font-size: 20px;
            border: 1px solid black;
         }
      </style>
   </head>
   <body onLoad="operate();">
      <h1>JavaScript Atomics Properties</h1>
      <div class="result"></div>
      <p>Atomics.add(arr, 0, 2)</p>
      <p>Atomics.load(arr, 0)</p>
      <script>
         function operate(){
            let container = document.querySelector(".result");
            // create a SharedArrayBuffer
            var buffer = new SharedArrayBuffer(25);
            var arr = new Uint8Array(buffer);
            // Initialise element at zeroth position of array with 6
            arr[0] = 6;
            container.innerHTML = Atomics.add(arr, 0, 2) + '<br/>' + Atomics.load(arr, 0);
         }
      </script>
   </body>
</html>

Salida

Verifique el resultado.

andEl método calcula el AND bit a bit con un valor proporcionado en una posición determinada en la matriz. Devuelve el valor anterior en esa posición. Esta operación atómica garantiza que no se pueda realizar ninguna otra escritura hasta que se vuelva a escribir el valor modificado.

Sintaxis

Atomics.and(typedArray, index, value)

Parámetros

  • typedArray es la matriz de tipo entero.

  • index es posición en typedarray.

  • value con el que se calculará el AND bit a bit.

Regreso

Devuelve el valor antiguo en la posición dada.

Excepciones

  • TypeError en caso de que la matriz pasada no sea una matriz de tipo entero.

  • RangeError si el índice pasado está fuera del límite en la matriz con tipo.

Ejemplo

A continuación se muestra el código para implementar JavaScript Atomics:

<!DOCTYPE html>
<html lang="en">
   <head>
      <meta charset="UTF-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
      <title>Atomics Example</title>
      <style>
         .result {
            font-size: 20px;
            border: 1px solid black;
         }
      </style>
   </head>
   <body onLoad="operate();">
      <h1>JavaScript Atomics Properties</h1>
      <div class="result"></div>
      <p>Atomics.and(arr, 0, 2)</p>
      <p>Atomics.load(arr, 0)</p>
      <script>
         function operate(){
            let container = document.querySelector(".result");
            // create a SharedArrayBuffer
            var buffer = new SharedArrayBuffer(25);
            var arr = new Uint8Array(buffer);
            // Initialise element at zeroth position of array with 6
            arr[0] = 6;
            //6 & 2 = 110 & 010 = 010 = 2
            container.innerHTML = Atomics.and(arr, 0, 2) + '<br/>'+ Atomics.load(arr, 0);
         }
      </script>
   </body>
</html>

Salida

Verifique el resultado.

compareExchangeEl método compara e intercambia un valor de reemplazo si el valor dado no es el mismo que el valor anterior. Devuelve el valor anterior en esa posición. Esta operación atómica garantiza que no se pueda realizar ninguna otra escritura hasta que se vuelva a escribir el valor modificado.

Sintaxis

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

Parámetros

  • typedArray es la matriz de tipo entero.

  • index es posición en typedarray.

  • expectedValue para comprobar la igualdad.

  • replacementValue a cambio.

Regreso

Devuelve el valor antiguo en la posición dada.

Excepciones

  • TypeError en caso de que la matriz pasada no sea una matriz de tipo entero.

  • RangeError si el índice pasado está fuera del límite en la matriz con tipo.

Ejemplo

A continuación se muestra el código para implementar JavaScript Atomics:

<!DOCTYPE html>
<html lang="en">
   <head>
      <meta charset="UTF-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
      <title>Atomics Example</title>
      <style>
         .result {
            font-size: 20px;
            border: 1px solid black;
         }
      </style>
   </head>
   <body onLoad="operate();">
      <h1>JavaScript Atomics Properties</h1>
      <div class="result"></div>
      <p>Atomics.compareExchange(arr, 0, 6, 2)</p>
      <p>Atomics.load(arr, 0)</p>
      <script>
         function operate(){
            let container = document.querySelector(".result");
            // create a SharedArrayBuffer
            var buffer = new SharedArrayBuffer(25);
            var arr = new Uint8Array(buffer);
            // Initialise element at zeroth position of array with 6
            arr[0] = 6;
            container.innerHTML = Atomics.compareExchange(arr, 0, 6, 2) + '<br/>' + Atomics.load(arr, 0);
         }
      </script>
   </body>
</html>

Salida

Verifique el resultado.

exchangeEl método intercambia un valor dado en una posición dada de una matriz. Devuelve el valor anterior en esa posición. Esta operación atómica garantiza que no se pueda realizar ninguna otra escritura hasta que se vuelva a escribir el valor modificado.

Sintaxis

Atomics.exchange(typedArray, index, value)

Parámetros

  • typedArray es la matriz de tipo entero.

  • index es posición en typedarray.

  • value a cambio.

Regreso

Devuelve el valor antiguo en la posición dada.

Excepciones

  • TypeError en caso de que la matriz pasada no sea una matriz de tipo entero.

  • RangeError si el índice pasado está fuera del límite en la matriz con tipo.

Ejemplo

A continuación se muestra el código para implementar JavaScript Atomics:

<!DOCTYPE html>
<html lang="en">
   <head>
      <meta charset="UTF-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
      <title>Atomics Example</title>
      <style>
         .result {
            font-size: 20px;
            border: 1px solid black;
         }
      </style>
   </head>
   <body onLoad="operate();">
      <h1>JavaScript Atomics Properties</h1>
      <div class="result"></div>
      <p>Atomics.exchange(arr, 0, 2)</p>
      <p>Atomics.load(arr, 0)</p>
      <script>
         function operate(){
            let container = document.querySelector(".result");
            // create a SharedArrayBuffer
            var buffer = new SharedArrayBuffer(25);
            var arr = new Uint8Array(buffer);
            // Initialise element at zeroth position of array with 6
            arr[0] = 6;
            container.innerHTML = Atomics.exchange(arr, 0, 2) + '<br/>' + Atomics.load(arr, 0);
         }
      </script>
   </body>
</html>

Salida

Verifique el resultado.

isLockFreeEl método se utiliza para determinar si las cerraduras se utilizarán o no para operaciones atómicas. Si el tamaño dado es una de las propiedades TypedArray.BYTES_PER_ELEMENT de los tipos integer TypedArray, devuelve verdadero. TypedArray.BYTES_PER_ELEMENT representa el tamaño en bytes de cada elemento de una matriz con tipo.

Sintaxis

Atomics.isLockFree(size)

Parámetros

  • size a comprobar en bytes.

Regreso

Devuelve verdadero si la operación está libre de bloqueos como falso.

Ejemplo

A continuación se muestra el código para implementar JavaScript Atomics:

<!DOCTYPE html>
<html lang="en">
   <head>
      <meta charset="UTF-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
      <title>Atomics Example</title>
      <style>
         .result {
            font-size: 20px;
            border: 1px solid black;
         }
      </style>
   </head>
   <body onLoad="operate();">
      <h1>JavaScript Atomics Properties</h1>
      <div class="result"></div>
      <p>Atomics.isLockFree(1)</p>
      <p>Atomics.isLockFree(3)</p>
      <script>
         function operate(){
            let container = document.querySelector(".result");
            // create a SharedArrayBuffer
            var buffer = new SharedArrayBuffer(25);
            var arr = new Uint8Array(buffer);
            // Initialise element at zeroth position of array with 6
            arr[0] = 6;
            // Int8Array.BYTES_PER_ELEMENT = 1
            container.innerHTML = Atomics.isLockFree(Int8Array.BYTES_PER_ELEMENT) + '<br/>' + Atomics.isLockFree(3);
         }
      </script>
   </body>
</html>

Salida

Verifique el resultado.

load El método devuelve un valor en la posición dada en la matriz.

Sintaxis

Atomics.load(typedArray, index)

Parámetros

  • typedArray es la matriz de tipo entero.

  • index es posición en typedarray.

Regreso

Devuelve el valor en la posición dada.

Excepciones

  • TypeError en caso de que la matriz pasada no sea una matriz de tipo entero.

  • RangeError si el índice pasado está fuera del límite en la matriz con tipo.

Ejemplo

A continuación se muestra el código para implementar JavaScript Atomics:

<!DOCTYPE html>
<html lang="en">
   <head>
      <meta charset="UTF-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
      <title>Atomics Example</title>
      <style>
         .result {
            font-size: 20px;
            border: 1px solid black;
         }
      </style>
   </head>
   <body onLoad="operate();">
      <h1>JavaScript Atomics Properties</h1>
      <div class="result"></div>
      <p>Atomics.add(arr, 0, 2)</p>
      <p>Atomics.load(arr, 0)</p>
      <script>
         function operate(){
            let container = document.querySelector(".result");
            // create a SharedArrayBuffer
            var buffer = new SharedArrayBuffer(25);
            var arr = new Uint8Array(buffer);
            // Initialise element at zeroth position of array with 6
            arr[0] = 6;
            container.innerHTML = Atomics.add(arr, 0, 2) + '<br/>' + Atomics.load(arr, 0);
         }
      </script>
   </body>
</html>

Salida

Verifique el resultado.

notifyEl método notifica al agente en espera que se despierte. El método de notificación puede funcionar solo con Int32Array creado usando SharedArrayBuffer. Devuelve 0 en caso de que se utilice un objeto ArrayBuffer no compartido.

Sintaxis

Atomics.notify(typedArray, index, count)

Parámetros

  • typedArray es un Int32Array compartido.

  • index es la posición en typedarray para despertar.

  • count es el número de agentes durmientes a notificar.

Regreso

Devuelve el número de agentes despertados.

Excepciones

  • TypeError en caso de que la matriz pasada no sea una matriz de tipo entero.

  • RangeError si el índice pasado está fuera del límite en la matriz con tipo.

Ejemplo

A continuación se muestra el código para implementar JavaScript Atomics:

<!DOCTYPE html>
<html lang="en">
   <head>
      <meta charset="UTF-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
      <title>Atomics Example</title>
      <style>
         .result {
            font-size: 20px;
            border: 1px solid black;
         }
      </style>
   </head>
   <body onLoad="operate();">
      <h1>JavaScript Atomics Properties</h1>
      <div class="result"></div>
      <p>Atomics.store(arr, 0, 5)</p>
      <p>Atomics.notify(arr, 0, 1)</p>
      <script>
         function operate(){
            let container = document.querySelector(".result");
            // create a SharedArrayBuffer
            var buffer = new SharedArrayBuffer(16);
            var arr = new Int32Array(buffer);
            // Initialise element at zeroth position of array with 6
            arr[0] = 6;            
            container.innerHTML = Atomics.store(arr, 0, 5) + '<br>' + Atomics.notify(arr, 0, 1);
         }
      </script>
   </body>
</html>

Salida

Verifique el resultado.

orEl método calcula el OR bit a bit con un valor proporcionado en una posición determinada en la matriz. Devuelve el valor anterior en esa posición. Esta operación atómica garantiza que no se pueda realizar ninguna otra escritura hasta que se vuelva a escribir el valor modificado.

Sintaxis

Atomics.or(typedArray, index, value)

Parámetros

  • typedArray es la matriz de tipo entero.

  • index es posición en typedarray.

  • value con qué OR bit a bit se calculará.

Regreso

Devuelve el valor antiguo en la posición dada.

Excepciones

  • TypeError en caso de que la matriz pasada no sea una matriz de tipo entero.

  • RangeError si el índice pasado está fuera del límite en la matriz con tipo.

Ejemplo

A continuación se muestra el código para implementar JavaScript Atomics:

<!DOCTYPE html>
<html lang="en">
   <head>
      <meta charset="UTF-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
      <title>Atomics Example</title>
      <style>
         .result {
            font-size: 20px;
            border: 1px solid black;
         }
      </style>
   </head>
   <body onLoad="operate();">
      <h1>JavaScript Atomics Properties</h1>
      <div class="result"></div>
      <p>Atomics.or(arr, 0, 2)</p>
      <p>Atomics.load(arr, 0)</p>
      <script>
         function operate(){
            let container = document.querySelector(".result");
            // create a SharedArrayBuffer
            var buffer = new SharedArrayBuffer(25);
            var arr = new Uint8Array(buffer);
            // Initialise element at zeroth position of array with 6
            arr[0] = 6;
            //6 | 2 = 110 | 010 = 110 = 6
            container.innerHTML = Atomics.or(arr, 0, 2) + '<br/>' + Atomics.load(arr, 0);
         }
      </script>
   </body>
</html>

Salida

Verifique el resultado.

storeEl método almacena un valor en la ubicación proporcionada en una matriz y devuelve el mismo. Esta operación atómica garantiza que no se pueda realizar ninguna otra escritura hasta que se vuelva a escribir el valor modificado.

Sintaxis

Atomics.store(typedArray, index, value)

Parámetros

  • typedArray es la matriz de tipo entero.

  • index es la posición en typedarray donde se almacenará el valor.

  • value para ser almacenado.

Regreso

Devuelve el valor almacenado en la posición dada.

Excepciones

  • TypeError en caso de que la matriz pasada no sea una matriz de tipo entero.

  • RangeError si el índice pasado está fuera del límite en la matriz con tipo.

Ejemplo

A continuación se muestra el código para implementar JavaScript Atomics:

<!DOCTYPE html>
<html lang="en">
   <head>
      <meta charset="UTF-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
      <title>Atomics Example</title>
      <style>
         .result {
            font-size: 20px;
            border: 1px solid black;
         }
      </style>
   </head>
   <body onLoad="operate();">
      <h1>JavaScript Atomics Properties</h1>
      <div class="result"></div>
      <p>Atomics.store(arr, 0, 2)</p>
      <p>Atomics.load(arr, 0)</p>
      <script>
         function operate(){
            let container = document.querySelector(".result");
            // create a SharedArrayBuffer
            var buffer = new SharedArrayBuffer(25);
            var arr = new Uint8Array(buffer);
            // Initialise element at zeroth position of array with 6
            arr[0] = 6;           
            container.innerHTML = Atomics.store(arr, 0, 2) + '<br/>'
            + Atomics.load(arr, 0);
         }
      </script>
   </body>
</html>

Salida

Verifique el resultado.

subEl método resta un valor proporcionado en una posición determinada en la matriz. Devuelve el valor anterior en esa posición. Esta operación atómica garantiza que no se pueda realizar ninguna otra escritura hasta que se vuelva a escribir el valor modificado.

Sintaxis

Atomics.sub(typedArray, index, value)

Parámetros

  • typedArray es la matriz de tipo entero.

  • index es posición en typedarray.

  • value a restar.

Regreso

Devuelve el valor antiguo en la posición dada.

Excepciones

  • TypeError en caso de que la matriz pasada no sea una matriz de tipo entero.

  • RangeError si el índice pasado está fuera del límite en la matriz con tipo.

Ejemplo

A continuación se muestra el código para implementar JavaScript Atomics:

<!DOCTYPE html>
<html lang="en">
   <head>
      <meta charset="UTF-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
      <title>Atomics Example</title>
      <style>
         .result {
            font-size: 20px;
            border: 1px solid black;
         }
      </style>
   </head>
   <body onLoad="operate();">
      <h1>JavaScript Atomics Properties</h1>
      <div class="result"></div>
      <p>Atomics.sub(arr, 0, 2)</p>
      <p>Atomics.load(arr, 0)</p>
      <script>
         function operate(){
            let container = document.querySelector(".result");
            // create a SharedArrayBuffer
            var buffer = new SharedArrayBuffer(25);
            var arr = new Uint8Array(buffer);
            // Initialise element at zeroth position of array with 6
            arr[0] = 6;
            //6 - 2 = 4
            container.innerHTML = Atomics.sub(arr, 0, 2) + '<br/>' + Atomics.load(arr, 0);
         }
      </script>
   </body>
</html>

Salida

Verifique el resultado.

xorEl método calcula el XOR bit a bit con un valor proporcionado en una posición dada en la matriz. Devuelve el valor anterior en esa posición. Esta operación atómica garantiza que no se pueda realizar ninguna otra escritura hasta que se vuelva a escribir el valor modificado.

Sintaxis

Atomics.xor(typedArray, index, value)

Parámetros

  • typedArray es la matriz de tipo entero.

  • index es posición en typedarray.

  • value con qué XOR bit a bit se calculará.

Regreso

Devuelve el valor antiguo en la posición dada.

Excepciones

  • TypeError en caso de que la matriz pasada no sea una matriz de tipo entero.

  • RangeError si el índice pasado está fuera del límite en la matriz con tipo.

Ejemplo

A continuación se muestra el código para implementar JavaScript Atomics:

<!DOCTYPE html>
<html lang="en">
   <head>
      <meta charset="UTF-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
      <title>Atomics Example</title>
      <style>
         .result {
            font-size: 20px;
            border: 1px solid black;
         }
      </style>
   </head>
   <body onLoad="operate();">
      <h1>JavaScript Atomics Properties</h1>
      <div class="result"></div>
      <p>Atomics.xor(arr, 0, 2)</p>
      <p>Atomics.load(arr, 0)</p>
      <script>
         function operate(){
            let container = document.querySelector(".result");
            // create a SharedArrayBuffer
            var buffer = new SharedArrayBuffer(25);
            var arr = new Uint8Array(buffer);
            // Initialise element at zeroth position of array with 6
            arr[0] = 6;
            //6 xor 2 = 110 xor 010 = 100 = 4
            container.innerHTML = Atomics.xor(arr, 0, 2) + '<br/>' + Atomics.load(arr, 0);
         }
      </script>
   </body>
</html>

Salida

Verifique el resultado.