Atomics - Guia Rápido

Atomics

O Atomics é um objeto em JavaScript que fornece operações atômicas a serem realizadas como métodos estáticos. Assim como os métodos do objeto Math, os métodos e propriedades do Atomics também são estáticos. Atomics são usados com objetos SharedArrayBuffer.

As operações Atomic são instaladas em um Atomics Module. Ao contrário de outros objetos globais, o Atomics não é um construtor. O Atomics não pode ser usado com um novo operador ou pode ser chamado como uma função.

Operações Atômicas

As operações atômicas são ininterruptas.

Quando a memória é compartilhada, vários threads podem ler ou gravar dados existentes na memória. Portanto, se algum dado for alterado, haverá perda de dados. As operações atômicas garantem que os valores previstos (dados) sejam gravados e lidos com precisão. As operações atômicas não serão iniciadas até e a menos que a operação atual seja concluída, portanto, não há como alterar os dados existentes.

Exemplo

A seguir está o código que demonstra o uso da Operação 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>

Resultado

Verifique o resultado.

Atomics

Operações Atômicas

As operações atômicas são ininterruptas.

Exemplo

A seguir está o código que demonstra o uso da Operação 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>

Resultado

Verifique o resultado.

addmétodo adiciona um valor fornecido em uma determinada posição na matriz. Ele retorna o valor antigo naquela posição. Essa operação atômica garante que nenhuma outra gravação possa ocorrer até que o valor modificado seja gravado de volta.

Sintaxe

Atomics.add(typedArray, index, value)

Parâmetros

typedArray é a matriz digitada por inteiro.
index é a posição no typedarray.
value para ser adicionado.

Retorna

Retorna o valor antigo em determinada posição.

Exceções

TypeError caso a matriz passada não seja uma matriz digitada por inteiro.
RangeError se o índice passado está fora do limite na matriz digitada.

Exemplo

A seguir está o 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>

Resultado

Verifique o resultado.

andO método calcula o bit a bit AND com um valor fornecido em uma determinada posição na matriz. Ele retorna o valor antigo naquela posição. Essa operação atômica garante que nenhuma outra gravação possa ocorrer até que o valor modificado seja gravado de volta.

Sintaxe

Atomics.and(typedArray, index, value)

Parâmetros

typedArray é a matriz digitada por inteiro.
index é a posição no typedarray.
value com o qual AND bit a bit deve ser calculado.

Retorna

Retorna o valor antigo em determinada posição.

Exceções

TypeError caso a matriz passada não seja uma matriz digitada por inteiro.
RangeError se o índice passado está fora do limite na matriz digitada.

Exemplo

A seguir está o 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>

Resultado

Verifique o resultado.

compareExchangemétodo compara e troca um valor de substituição se o valor fornecido não for igual ao valor antigo. Ele retorna o valor antigo naquela posição. Essa operação atômica garante que nenhuma outra gravação possa ocorrer até que o valor modificado seja gravado de volta.

Sintaxe

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

Parâmetros

typedArray é a matriz digitada por inteiro.
index é a posição no typedarray.
expectedValue para verificar a igualdade.
replacementValue para trocar.

Retorna

Retorna o valor antigo em determinada posição.

Exceções

TypeError caso a matriz passada não seja uma matriz digitada por inteiro.
RangeError se o índice passado está fora do limite na matriz digitada.

Exemplo

A seguir está o 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>

Resultado

Verifique o resultado.

exchangemétodo troca um determinado valor em determinada posição de uma matriz. Ele retorna o valor antigo naquela posição. Essa operação atômica garante que nenhuma outra gravação possa ocorrer até que o valor modificado seja gravado de volta.

Sintaxe

Atomics.exchange(typedArray, index, value)

Parâmetros

typedArray é a matriz digitada por inteiro.
index é a posição no typedarray.
value para trocar.

Retorna

Retorna o valor antigo em determinada posição.

Exceções

TypeError caso a matriz passada não seja uma matriz digitada por inteiro.
RangeError se o índice passado está fora do limite na matriz digitada.

Exemplo

A seguir está o 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>

Resultado

Verifique o resultado.

isLockFreemétodo é usado para determinar se os bloqueios devem ser usados ou não para operações atômicas. Se o tamanho fornecido for uma das propriedades TypedArray.BYTES_PER_ELEMENT dos tipos TypedArray inteiros, então ele retorna verdadeiro. TypedArray.BYTES_PER_ELEMENT representa o tamanho em bytes de cada elemento de uma matriz digitada.

Sintaxe

Atomics.isLockFree(size)

Parâmetros

size a ser verificado em bytes.

Retorna

Retorna verdadeiro se a operação está livre de bloqueio como falsa.

Exemplo

A seguir está o 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>

Resultado

Verifique o resultado.

load método retorna um valor em determinada posição na matriz.

Sintaxe

Atomics.load(typedArray, index)

Parâmetros

typedArray é a matriz digitada por inteiro.
index é a posição no typedarray.

Retorna

Retorna o valor na posição fornecida.

Exceções

TypeError caso a matriz passada não seja uma matriz digitada por inteiro.
RangeError se o índice passado está fora do limite na matriz digitada.

Exemplo

A seguir está o 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>

Resultado

Verifique o resultado.

notifymétodo notifica o agente em espera para acordar. O método de notificação pode funcionar apenas com Int32Array criado usando SharedArrayBuffer. Ele retorna 0 no caso de um objeto ArrayBuffer não compartilhado ser usado.

Sintaxe

Atomics.notify(typedArray, index, count)

Parâmetros

typedArray é um Int32Array compartilhado.
index é a posição no typedarray para ativar.
count é o número de agentes adormecidos a serem notificados.

Retorna

Retorna o número de agentes acordados.

Exceções

TypeError caso a matriz passada não seja uma matriz digitada por inteiro.
RangeError se o índice passado está fora do limite na matriz digitada.

Exemplo

A seguir está o 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>

Resultado

Verifique o resultado.

ormétodo calcula o bit a bit OR com um valor fornecido em uma determinada posição na matriz. Ele retorna o valor antigo naquela posição. Essa operação atômica garante que nenhuma outra gravação possa ocorrer até que o valor modificado seja gravado de volta.

Sintaxe

Atomics.or(typedArray, index, value)

Parâmetros

typedArray é a matriz digitada por inteiro.
index é a posição no typedarray.
value com qual OR bit a bit deve ser calculado.

Retorna

Retorna o valor antigo em determinada posição.

Exceções

TypeError caso a matriz passada não seja uma matriz digitada por inteiro.
RangeError se o índice passado está fora do limite na matriz digitada.

Exemplo

A seguir está o 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>

Resultado

Verifique o resultado.

storemétodo armazena um valor no local fornecido em uma matriz e retorna o mesmo. Essa operação atômica garante que nenhuma outra gravação possa ocorrer até que o valor modificado seja gravado de volta.

Sintaxe

Atomics.store(typedArray, index, value)

Parâmetros

typedArray é a matriz digitada por inteiro.
index é a posição no typedarray onde o valor deve ser armazenado.
value para ser armazenado.

Retorna

Retorna o valor armazenado na posição fornecida.

Exceções

TypeError caso a matriz passada não seja uma matriz digitada por inteiro.
RangeError se o índice passado está fora do limite na matriz digitada.

Exemplo

A seguir está o 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>

Resultado

Verifique o resultado.

submétodo subtrai um valor fornecido em uma determinada posição na matriz. Ele retorna o valor antigo naquela posição. Essa operação atômica garante que nenhuma outra gravação possa ocorrer até que o valor modificado seja gravado de volta.

Sintaxe

Atomics.sub(typedArray, index, value)

Parâmetros

typedArray é a matriz digitada por inteiro.
index é a posição no typedarray.
value a ser subtraído.

Retorna

Retorna o valor antigo em determinada posição.

Exceções

TypeError caso a matriz passada não seja uma matriz digitada por inteiro.
RangeError se o índice passado está fora do limite na matriz digitada.

Exemplo

A seguir está o 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>

Resultado

Verifique o resultado.

xorO método calcula o XOR bit a bit com um valor fornecido em uma determinada posição na matriz. Ele retorna o valor antigo naquela posição. Essa operação atômica garante que nenhuma outra gravação possa ocorrer até que o valor modificado seja gravado de volta.

Sintaxe

Atomics.xor(typedArray, index, value)

Parâmetros

typedArray é a matriz digitada por inteiro.
index é a posição no typedarray.
value com qual XOR bit a bit deve ser calculado.

Retorna

Retorna o valor antigo em determinada posição.

Exceções

TypeError caso a matriz passada não seja uma matriz digitada por inteiro.
RangeError se o índice passado está fora do limite na matriz digitada.

Exemplo

A seguir está o 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>

Resultado

Verifique o resultado.

↰ Previous page