Atomics

Beschreibung

Anders als die meisten globalen Objekte ist Atomics kein Konstruktor. Sie können es weder mit dem new-Operator verwenden noch das Atomics-Objekt als Funktion aufrufen. Alle Eigenschaften und Methoden von Atomics sind statisch (genau wie beim Math-Objekt).

Statische Eigenschaften

Atomics[Symbol.toStringTag]

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

Statische Methoden

Atomics.add()

Addiert den übergebenen Wert zum vorhandenen Wert am angegebenen Index des Arrays. Gibt den vorherigen Wert an diesem Index zurück.

Atomics.and()

Führt eine bitweise UND-Operation mit dem Wert am angegebenen Index des Arrays und dem übergebenen Wert durch. Gibt den vorherigen Wert an diesem Index zurück.

Atomics.compareExchange()

Speichert einen Wert am angegebenen Index des Arrays, wenn der dort vorhandene Wert einem Vergleichswert entspricht. Gibt den vorherigen Wert zurück.

Atomics.exchange()

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

Atomics.isLockFree()

Ein Optimierungsprimitiv, mit dem sich bestimmen lässt, ob Sperren oder atomare Operationen verwendet werden sollen. Gibt true zurück, wenn eine atomare Operation auf Arrays mit der angegebenen Elementgröße durch eine atomare Hardwareoperation implementiert wird (und nicht mithilfe einer Sperre). Nur für Fachleute.

Atomics.load()

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

Atomics.notify()

Benachrichtigt Agents, die am angegebenen Index des Arrays warten. Gibt die Anzahl der benachrichtigten Agents zurück.

Atomics.or()

Führt eine bitweise ODER-Operation mit dem Wert am angegebenen Index des Arrays und dem übergebenen Wert durch. Gibt den vorherigen Wert an diesem Index zurück.

Atomics.pause()

Stellt ein Primitiv für sehr kurzes Warten bereit, das der CPU signalisiert, dass der Aufrufer in einer Warteschleife auf den Zugriff auf eine gemeinsam genutzte Ressource wartet. Dadurch kann das System die dem Prozessorkern zugewiesenen Ressourcen (etwa Energie) oder die dem Thread zugewiesenen Ressourcen reduzieren, ohne die Ausführung des aktuellen Threads abzugeben.

Atomics.store()

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

Atomics.sub()

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

Atomics.wait()

Prüft, ob der angegebene Index des Arrays noch einen bestimmten Wert enthält, und wartet dann, bis eine Benachrichtigung eintrifft oder die Wartezeit abläuft. Gibt entweder "ok", "not-equal" oder "timed-out" zurück. Wenn das Warten im aufrufenden Agent nicht erlaubt ist, wird eine Ausnahme ausgelöst. (Die meisten Browser erlauben wait() nicht im Hauptthread des Browsers.)

Atomics.waitAsync()

Wartet asynchron (also ohne zu blockieren, anders als Atomics.wait) auf eine gemeinsam genutzte Speicherstelle und gibt ein Objekt zurück, das das Ergebnis der Operation darstellt.

Atomics.xor()

Führt eine bitweise XOR-Operation mit dem Wert am angegebenen Index des Arrays und dem übergebenen Wert durch. Gibt den vorherigen Wert an diesem Index zurück.

Beispiele

Beachten Sie, dass diese Beispiele nicht direkt in der Konsole oder auf einer beliebigen Webseite ausgeführt werden können, da SharedArrayBuffer nur definiert ist, wenn seine Sicherheitsanforderungen erfüllt sind.

Atomics verwenden

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 sei ein gemeinsam genutztes Int32Array:

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

Ein lesender Thread wartet an Position 0, weil der übergebene Wert mit dem an diesem Index gespeicherten Wert übereinstimmt. Der lesende Thread wird erst fortgesetzt, wenn der schreibende Thread Atomics.notify() für Position 0 des übergebenen typisierten Arrays aufgerufen hat. Beachten Sie: Wenn der schreibende Thread den Wert an Position 0 bis zum Aufwecken nicht geändert hat, wartet der lesende Thread nicht erneut, sondern wird fortgesetzt.

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

Ein schreibender Thread speichert einen neuen Wert und benachrichtigt anschließend den wartenden Thread:

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

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Leitfaden zur Kommunikation und Koordination von Agents
• ArrayBuffer
• Leitfaden zu typisierten JavaScript-Arrays
• Web Workers
• Shared Memory – eine kurze Einführung im TC39-Vorschlag ecmascript-sharedmem
• Ein Vorgeschmack auf die neuen Parallelitätsprimitive von JavaScript auf hacks.mozilla.org (2016)