Atomics - Kurzanleitung

Atomics

Atomics ist ein Objekt in JavaScript, das atomare Operationen bereitstellt, die als statische Methoden ausgeführt werden können. Genau wie die Methoden des Math-Objekts sind auch die Methoden und Eigenschaften von Atomics statisch. Atomics werden mit SharedArrayBuffer-Objekten verwendet.

Die Atomic-Operationen werden auf einem Atomics-Modul installiert. Im Gegensatz zu anderen globalen Objekten ist Atomics kein Konstruktor. Atomics kann nicht mit einem neuen Operator verwendet oder als Funktion aufgerufen werden.

Atomoperationen

Atomoperationen sind unterbrechungsfrei.

Wenn der Speicher gemeinsam genutzt wird, können mehrere Threads vorhandene Daten im Speicher lesen oder schreiben. Wenn also Daten geändert werden, gehen Daten verloren. Atomic-Operationen stellen sicher, dass die vorhergesagten Werte (Daten) genau geschrieben und gelesen werden. Atomische Operationen werden erst gestartet, wenn die aktuelle Operation beendet ist. Daher gibt es keine Möglichkeit, vorhandene Daten zu ändern.

Beispiel

Im Folgenden finden Sie den Code, der die Verwendung von JavaScript Atomics Operation demonstriert.

<!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>

Ausgabe

Überprüfen Sie das Ergebnis.

Atomics

Atomoperationen

Atomoperationen sind unterbrechungsfrei.

Beispiel

Im Folgenden finden Sie den Code, der die Verwendung von JavaScript Atomics Operation demonstriert.

<!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>

Ausgabe

Überprüfen Sie das Ergebnis.

addMethode fügt einen bereitgestellten Wert an einer bestimmten Position im Array hinzu. Es gibt den alten Wert an dieser Position zurück. Diese atomare Operation stellt sicher, dass kein weiterer Schreibvorgang ausgeführt werden kann, bis der geänderte Wert zurückgeschrieben wird.

Syntax

Atomics.add(typedArray, index, value)

Parameter

typedArray ist das ganzzahlige Array.
index ist die Position in typedarray.
value hinzugefügt werden.

Rückkehr

Gibt den alten Wert an der angegebenen Position zurück.

Ausnahmen

TypeError Für den Fall, dass das übergebene Array kein ganzzahliges Array ist.
RangeError Wenn der übergebene Index in einem typisierten Array nicht gebunden ist.

Beispiel

Im Folgenden finden Sie den Code zum Implementieren von 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>

Ausgabe

Überprüfen Sie das Ergebnis.

andDie Methode berechnet das bitweise UND mit einem angegebenen Wert an einer bestimmten Position im Array. Es gibt den alten Wert an dieser Position zurück. Diese atomare Operation stellt sicher, dass kein weiterer Schreibvorgang ausgeführt werden kann, bis der geänderte Wert zurückgeschrieben wird.

Syntax

Atomics.and(typedArray, index, value)

Parameter

typedArray ist das ganzzahlige Array.
index ist die Position in typedarray.
value mit welchem bitweisen UND berechnet werden soll.

Rückkehr

Gibt den alten Wert an der angegebenen Position zurück.

Ausnahmen

TypeError Für den Fall, dass das übergebene Array kein ganzzahliges Array ist.
RangeError Wenn der übergebene Index in einem typisierten Array nicht gebunden ist.

Beispiel

Im Folgenden finden Sie den Code zum Implementieren von 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>

Ausgabe

Überprüfen Sie das Ergebnis.

compareExchangeDie Methode vergleicht einen Austauschwert und tauscht ihn aus, wenn der angegebene Wert nicht mit dem alten Wert übereinstimmt. Es gibt den alten Wert an dieser Position zurück. Diese atomare Operation stellt sicher, dass kein weiterer Schreibvorgang ausgeführt werden kann, bis der geänderte Wert zurückgeschrieben wird.

Syntax

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

Parameter

typedArray ist das ganzzahlige Array.
index ist die Position in typedarray.
expectedValue auf Gleichheit prüfen.
replacementValue wechseln.

Rückkehr

Gibt den alten Wert an der angegebenen Position zurück.

Ausnahmen

TypeError Für den Fall, dass das übergebene Array kein ganzzahliges Array ist.
RangeError Wenn der übergebene Index in einem typisierten Array nicht gebunden ist.

Beispiel

Im Folgenden finden Sie den Code zum Implementieren von 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>

Ausgabe

Überprüfen Sie das Ergebnis.

exchangeDie Methode tauscht einen bestimmten Wert an einer bestimmten Position eines Arrays aus. Es gibt den alten Wert an dieser Position zurück. Diese atomare Operation stellt sicher, dass kein weiterer Schreibvorgang ausgeführt werden kann, bis der geänderte Wert zurückgeschrieben wird.

Syntax

Atomics.exchange(typedArray, index, value)

Parameter

typedArray ist das ganzzahlige Array.
index ist die Position in typedarray.
value wechseln.

Rückkehr

Gibt den alten Wert an der angegebenen Position zurück.

Ausnahmen

TypeError Für den Fall, dass das übergebene Array kein ganzzahliges Array ist.
RangeError Wenn der übergebene Index in einem typisierten Array nicht gebunden ist.

Beispiel

Im Folgenden finden Sie den Code zum Implementieren von 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>

Ausgabe

Überprüfen Sie das Ergebnis.

isLockFreeDie Methode wird verwendet, um zu bestimmen, ob Sperren für atomare Operationen verwendet werden sollen oder nicht. Wenn die angegebene Größe eine der TypedArray.BYTES_PER_ELEMENT-Eigenschaften von ganzzahligen TypedArray-Typen ist, wird true zurückgegeben. TypedArray.BYTES_PER_ELEMENT repräsentiert die Größe jedes Elements eines typisierten Arrays in Byte.

Syntax

Atomics.isLockFree(size)

Parameter

size in Bytes geprüft werden.

Rückkehr

Gibt true zurück, wenn die Operation als false gesperrt ist.

Beispiel

Im Folgenden finden Sie den Code zum Implementieren von 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>

Ausgabe

Überprüfen Sie das Ergebnis.

load Methode gibt einen Wert an einer bestimmten Position im Array zurück.

Syntax

Atomics.load(typedArray, index)

Parameter

typedArray ist das ganzzahlige Array.
index ist die Position in typedarray.

Rückkehr

Gibt den Wert an der angegebenen Position zurück.

Ausnahmen

TypeError Für den Fall, dass das übergebene Array kein ganzzahliges Array ist.
RangeError Wenn der übergebene Index in einem typisierten Array nicht gebunden ist.

Beispiel

Im Folgenden finden Sie den Code zum Implementieren von 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>

Ausgabe

Überprüfen Sie das Ergebnis.

notifyMethode benachrichtigt den wartenden Agenten, um aufzuwachen. Die Benachrichtigungsmethode kann nur mit Int32Array verwendet werden, das mit SharedArrayBuffer erstellt wurde. Es wird 0 zurückgegeben, wenn ein nicht gemeinsam genutztes ArrayBuffer-Objekt verwendet wird.

Syntax

Atomics.notify(typedArray, index, count)

Parameter

typedArray ist ein gemeinsam genutztes Int32Array.
index ist die Position in typedarray zum Aufwachen.
count ist die Anzahl der zu benachrichtigenden Schlafmittel.

Rückkehr

Gibt die Anzahl der aufgeweckten Agenten zurück.

Ausnahmen

TypeError Für den Fall, dass das übergebene Array kein ganzzahliges Array ist.
RangeError Wenn der übergebene Index in einem typisierten Array nicht gebunden ist.

Beispiel

Im Folgenden finden Sie den Code zum Implementieren von 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>

Ausgabe

Überprüfen Sie das Ergebnis.

orDie Methode berechnet das bitweise ODER mit einem angegebenen Wert an einer bestimmten Position im Array. Es gibt den alten Wert an dieser Position zurück. Diese atomare Operation stellt sicher, dass kein weiterer Schreibvorgang ausgeführt werden kann, bis der geänderte Wert zurückgeschrieben wird.

Syntax

Atomics.or(typedArray, index, value)

Parameter

typedArray ist das ganzzahlige Array.
index ist die Position in typedarray.
value mit welchem bitweisen ODER berechnet werden soll.

Rückkehr

Gibt den alten Wert an der angegebenen Position zurück.

Ausnahmen

TypeError Für den Fall, dass das übergebene Array kein ganzzahliges Array ist.
RangeError Wenn der übergebene Index in einem typisierten Array nicht gebunden ist.

Beispiel

Im Folgenden finden Sie den Code zum Implementieren von 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>

Ausgabe

Überprüfen Sie das Ergebnis.

storeDie Methode speichert einen Wert an der angegebenen Stelle in einem Array und gibt denselben zurück. Diese atomare Operation stellt sicher, dass kein weiterer Schreibvorgang ausgeführt werden kann, bis der geänderte Wert zurückgeschrieben wird.

Syntax

Atomics.store(typedArray, index, value)

Parameter

typedArray ist das ganzzahlige Array.
index ist die Position in typedarray, an der der Wert gespeichert werden soll.
value zu speichernden.

Rückkehr

Gibt den an der angegebenen Position gespeicherten Wert zurück.

Ausnahmen

TypeError Für den Fall, dass das übergebene Array kein ganzzahliges Array ist.
RangeError Wenn der übergebene Index in einem typisierten Array nicht gebunden ist.

Beispiel

Im Folgenden finden Sie den Code zum Implementieren von 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>

Ausgabe

Überprüfen Sie das Ergebnis.

subDie Methode subtrahiert einen bereitgestellten Wert an einer bestimmten Position im Array. Es gibt den alten Wert an dieser Position zurück. Diese atomare Operation stellt sicher, dass kein weiterer Schreibvorgang ausgeführt werden kann, bis der geänderte Wert zurückgeschrieben wird.

Syntax

Atomics.sub(typedArray, index, value)

Parameter

typedArray ist das ganzzahlige Array.
index ist die Position in typedarray.
value abgezogen werden.

Rückkehr

Gibt den alten Wert an der angegebenen Position zurück.

Ausnahmen

TypeError Für den Fall, dass das übergebene Array kein ganzzahliges Array ist.
RangeError Wenn der übergebene Index in einem typisierten Array nicht gebunden ist.

Beispiel

Im Folgenden finden Sie den Code zum Implementieren von 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>

Ausgabe

Überprüfen Sie das Ergebnis.

xorDie Methode berechnet das bitweise XOR mit einem angegebenen Wert an einer bestimmten Position im Array. Es gibt den alten Wert an dieser Position zurück. Diese atomare Operation stellt sicher, dass kein weiterer Schreibvorgang ausgeführt werden kann, bis der geänderte Wert zurückgeschrieben wird.

Syntax

Atomics.xor(typedArray, index, value)

Parameter

typedArray ist das ganzzahlige Array.
index ist die Position in typedarray.
value mit welchem bitweisen XOR berechnet werden soll.

Rückkehr

Gibt den alten Wert an der angegebenen Position zurück.

Ausnahmen

TypeError Für den Fall, dass das übergebene Array kein ganzzahliges Array ist.
RangeError Wenn der übergebene Index in einem typisierten Array nicht gebunden ist.

Beispiel

Im Folgenden finden Sie den Code zum Implementieren von 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>

Ausgabe

Überprüfen Sie das Ergebnis.