Atomics

Baseline Widely available *

This feature is well established and works across many devices and browser versions. It’s been available across browsers since December 2021.

* Some parts of this feature may have varying levels of support.

Das Atomics Namensraumobjekt enthält statische Methoden zur Durchführung atomarer Operationen. Sie werden mit SharedArrayBuffer und ArrayBuffer Objekten verwendet.

Beschreibung

Im Gegensatz zu den meisten globalen Objekten ist Atomics kein Konstruktor. Sie können es nicht mit dem new Operator verwenden oder das Atomics Objekt als Funktion aufrufen. Alle Eigenschaften und Methoden von Atomics sind statisch (genau wie das Math Objekt).

Atomare Operationen

Wenn Speicher geteilt wird, können mehrere Threads die gleichen Daten im Speicher lesen und schreiben. Atomare Operationen stellen sicher, dass vorhersehbare Werte geschrieben und gelesen werden, dass Operationen abgeschlossen sind, bevor die nächste beginnt, und dass Operationen nicht unterbrochen werden.

Warten und Benachrichtigen

Die wait() und notify() Methoden sind an Linux-Futexe ("fast user-space mutex") angelehnt und bieten Möglichkeiten, zu warten, bis eine bestimmte Bedingung erfüllt ist, und werden typischerweise als blockierende Konstrukte verwendet.

Statische Eigenschaften

Atomics[Symbol.toStringTag]

Der Anfangswert der [Symbol.toStringTag] Eigenschaft ist der String "Atomics". Diese Eigenschaft wird in Object.prototype.toString() verwendet.

Statische Methoden

Atomics.add()

Fügt den bereitgestellten Wert zum vorhandenen Wert am angegebenen Index des Arrays hinzu. Gibt den alten Wert an diesem Index zurück.

Atomics.and()

Führt ein bitweises UND mit dem Wert am angegebenen Index des Arrays und dem bereitgestellten Wert durch. Gibt den alten Wert an diesem Index zurück.

Atomics.compareExchange()

Speichert einen Wert am angegebenen Index des Arrays, wenn er einem Wert entspricht. Gibt den alten Wert zurück.

Atomics.exchange()

Speichert einen Wert am angegebenen Index des Arrays. Gibt den alten Wert zurück.

Atomics.isLockFree()

Ein Optimierungsprimitiv, das verwendet werden kann, um festzustellen, ob Schlösser oder atomare Operationen verwendet werden sollen. Gibt true zurück, wenn eine atomare Operation auf Arrays der gegebenen Elementgröße mittels einer Hardware-Atomoperation (statt eines Schlosses) implementiert wird. Nur für Experten.

Atomics.load()

Gibt den Wert am angegebenen Index des Arrays zurück.

Atomics.notify()

Benachrichtigt Agenten, die am angegebenen Index des Arrays warten. Gibt die Anzahl der Agenten zurück, die benachrichtigt wurden.

Atomics.or()

Führt ein bitweises ODER mit dem Wert am angegebenen Index des Arrays und dem bereitgestellten Wert durch. Gibt den alten Wert an diesem Index zurück.

Atomics.store()

Speichert einen Wert am angegebenen Index des Arrays. Gibt den Wert zurück.

Atomics.sub()

Subtrahiert einen Wert am angegebenen Index des Arrays. Gibt den alten Wert an diesem Index zurück.

Atomics.wait()

Überprüft, ob der angegebene Index des Arrays noch einen Wert enthält, und schläft wartend oder läuft ab. Gibt entweder "ok", "not-equal" oder "timed-out" zurück. Wenn das Warten im aufrufenden Agenten nicht erlaubt ist, löst es eine Ausnahme aus. (Die meisten Browser erlauben wait() nicht im Hauptthread des Browsers.)

Atomics.waitAsync()

Wartet asynchron (d.h. ohne Blockieren, im Gegensatz zu Atomics.wait) an einem gemeinsamen Speicherort und gibt ein Objekt zurück, das das Ergebnis der Operation darstellt.

Atomics.xor()

Führt ein bitweises XOR mit dem Wert am angegebenen Index des Arrays und dem bereitgestellten Wert durch. Gibt den alten Wert an diesem Index zurück.

Beispiele

Verwendung von Atomics

js
const sab = new SharedArrayBuffer(1024);
const ta = new Uint8Array(sab);

ta[0]; // 0
ta[0] = 5; // 5

Atomics.add(ta, 0, 12); // 5
Atomics.load(ta, 0); // 17

Atomics.and(ta, 0, 1); // 17
Atomics.load(ta, 0); // 1

Atomics.compareExchange(ta, 0, 5, 12); // 1
Atomics.load(ta, 0); // 1

Atomics.exchange(ta, 0, 12); // 1
Atomics.load(ta, 0); // 12

Atomics.isLockFree(1); // true
Atomics.isLockFree(2); // true
Atomics.isLockFree(3); // false
Atomics.isLockFree(4); // true

Atomics.or(ta, 0, 1); // 12
Atomics.load(ta, 0); // 13

Atomics.store(ta, 0, 12); // 12

Atomics.sub(ta, 0, 2); // 12
Atomics.load(ta, 0); // 10

Atomics.xor(ta, 0, 1); // 10
Atomics.load(ta, 0); // 11

Warten und Benachrichtigen

Gegeben ein geteilter Int32Array:

js
const sab = new SharedArrayBuffer(1024);
const int32 = new Int32Array(sab);

Ein lesender Thread schläft und wartet auf Position 0, weil der bereitgestellte Wert mit dem übereinstimmt, was an dem bereitgestellten Index gespeichert ist. Der lesende Thread wird nicht fortfahren, bis der schreibende Thread Atomics.notify() auf Position 0 des bereitgestellten typisierten Arrays aufgerufen hat. Beachten Sie, dass der lesende Thread, wenn nach dem Aufwachen der Wert der Position 0 nicht durch den schreibenden Thread geändert wurde, NICHT wieder schlafen geht, sondern fortfährt.

js
Atomics.wait(int32, 0, 0);
console.log(int32[0]); // 123

Ein schreibender Thread speichert einen neuen Wert und benachrichtigt den wartenden Thread, sobald er geschrieben hat:

js
console.log(int32[0]); // 0;
Atomics.store(int32, 0, 123);
Atomics.notify(int32, 0, 1);

Spezifikationen

Specification
ECMAScript Language Specification
# sec-atomics-object

Browser-Kompatibilität

BCD tables only load in the browser

Siehe auch