DieAtomics.pause() statische Methode bietet eine Mikro-Warteschleifenprimitive, die der CPU signalisiert, dass der Aufrufer in einer Schleife wartet, während er auf den Zugriff auf eine gemeinsame Ressource wartet. Dies ermöglicht es dem System, die einem Kern (wie z.B. Strom) oder Thread zugewiesenen Ressourcen zu reduzieren, ohne den aktuellen Thread freizugeben.

pause() hat kein beobachtbares Verhalten außer der Zeitdauer. Das genaue Verhalten hängt von der CPU-Architektur und dem Betriebssystem ab. Beispielsweise könnte es in Intel x86 einepause-Instruktion gemäßIntels Optimierungshandbuch sein. Auf bestimmten Plattformen könnte es ein No-op sein.

Syntax

Atomics.pause()Atomics.pause(durationHint)

Parameter

durationHintOptional

Ein Integer, den eine Implementierung verwenden kann, um zu bestimmen, wie lange gewartet werden soll. Für einen Wert vonn + 1 wartet eine Implementierung mindestens so lange, wie für einen gegebenen Wertn. Die genaue Zahl hat keine physikalische Bedeutung. Es könnte eine interne Obergrenze für die maximale Wartezeit im Bereich von Dutzenden bis Hunderten von Nanosekunden geben. Dies kann verwendet werden, um eineBackoff-Strategie zu implementieren, indem man den übergebenendurationHint erhöht. Es gibt keine Garantie, dass eine Implementierung diesen Hinweis verwendet.

Rückgabewert

Kein (undefined).

Ausnahmen

TypeError

Wird ausgelöst, wenndurationHint kein Integer oderundefined ist.

Beispiele

Verwendung von Atomics.pause()

Der Aufruf vonAtomics.wait() oderAtomics.waitAsync(), um auf den Zugriff auf gemeinsamen Speicher zu warten, führt dazu, dass der Thread aus dem Kern ausgelagert und nach der Wartezeit wieder eingelagert wird. Dies ist effizient bei hoher Konkurrenz, wenn der Zugriff auf den gemeinsamen Speicher einige Zeit in Anspruch nehmen könnte. Bei niedriger Konkurrenz ist es oft effizienter, die Sperre abzufragen, ohne den Thread freizugeben: Dieser Ansatz ist bekannt alsBusy Waiting oderSpinlocking. Die Methodepause() ermöglicht es Ihnen, effizienter zu spinlocken, indem sie der CPU einen Hinweis darauf gibt, was der Thread tut und daher seinen geringen Ressourcenbedarf signalisiert.

Um beide Bedingungen abzudecken, ist ein gebräuchlicher Ansatz zuerst zu spinlocken in der Hoffnung, dass die Konkurrenz gering ist, und dann zu warten, wenn die Sperre nach kurzer Zeit nicht erlangt wird. Wenn die Sperre bereits durch Spinlocking erlangt wurde, wird derwait()-Aufruf eine No-op sein.

Das untenstehende Beispiel zeigt, wie dieser Ansatz mitAtomics.pause() undAtomics.wait() verwendet werden kann.

// Imagine another thread also has access to this shared memoryconst sab = new SharedArrayBuffer(1024);const i32 = new Int32Array(sab);// Fast path: spin the CPU for a short whilelet spin = 0;do {  if (Atomics.compareExchange(i32, 0, 0, 1) === 0) {    break;  }  Atomics.pause();  spin++;} while (spin < 10);// Slow path: wait for the lock// This can only be called in a worker thread,// because the main thread cannot be blockedAtomics.wait(i32, 0, 1);

Backoff-Strategien

DerdurationHint Parameter kann verwendet werden, um Backoff-Strategien zu implementieren. Beispielsweise kann ein Thread mit einem kleinen Hinweis beginnen und diesen bei jeder Iteration exponentiell erhöhen. Dies ist vorzuziehen, anstelle viele Malepause() aufzurufen, da in nicht-jitierten Code Funktionsaufrufe selbst einen hohen Overhead haben.

// Exponential backofffor (let hint = 1; hint < 1000; hint *= 2) {  Atomics.pause(hint);}// Linear backofffor (let hint = 1; hint < 100; hint++) {  Atomics.pause(hint);}

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Atomics
• Atomics.wait()
• Atomics.waitAsync()