Atomics : méthode statique pause()
Baseline
2025
Nouvellement disponible
Depuis avril 2025, cette fonctionnalité fonctionne sur les appareils et les versions de navigateur les plus récents. Elle peut ne pas fonctionner sur les appareils ou navigateurs plus anciens.
La méthode statique Atomics.pause() fournit une primitive de micro‑attente qui indique au processeur que l'appelant effectue une boucle d'attente active en attendant l'accès à une ressource partagée. Cela permet au système de réduire les ressources allouées au cœur (par exemple la consommation d'énergie) ou au processus, sans céder l'exécution du processus courant.
pause() n'a pas d'effet observable autre que le temps d'attente. Le comportement exact dépend de l'architecture du processeur et du système d'exploitation. Par exemple, sur Intel x86, il peut s'agir d'une instruction pause comme indiqué dans le manuel d'optimisation d'Intel (angl.). Sur certaines plateformes, il peut s'agir d'une opération sans effet.
Syntaxe
Atomics.pause()
Paramètres
Aucun.
Valeur de retour
Aucune (undefined).
Exemples
Notez que ces exemples ne peuvent pas être exécutés directement depuis la console ou une page web arbitraire, car SharedArrayBuffer n'est pas défini à moins que ses exigences de sécurité ne soient respectées.
Utiliser la méthode Atomics.pause()
Appeler Atomics.wait() ou Atomics.waitAsync() pour attendre l'accès à une mémoire partagée entraîne la mise hors du cœur du fil d'exécution, puis son retour après l'attente. Cela est efficace en période de forte contention, où l'accès à la mémoire partagée peut prendre un certain temps. Lorsque la contention est faible, il est souvent plus efficace de sonder le verrou sans céder le fil d'exécution : cette approche est connue sous le nom d'attente active ou de verrou tournant. La méthode pause() permet d'effectuer l'attente active de manière plus efficace en fournissant au processeur un indice sur ce que fait le fil d'exécution, et donc sur son faible besoin en ressources.
Pour couvrir les deux cas, une approche courante consiste d'abord à effectuer une attente active en espérant que la contention est faible, puis à attendre si le verrou n'est pas acquis après un court laps de temps. Si le verrou a déjà été acquis avec l'attente active, l'appel à wait() est une opération sans effet.
L'exemple ci-dessous montre comment utiliser Atomics.pause() et Atomics.wait().
Attention : L'utilisation des verrous tournants sur le thread principal n'est pas recommandée, car elle figerait la page entière. En général, à moins d'être conçus avec beaucoup de soin, les verrous tournants peuvent ne pas être plus performants qu'une attente normale.
// Imaginez qu'un autre processus a aussi accès à cette mémoire partagée
const sab = new SharedArrayBuffer(1024);
const i32 = new Int32Array(sab);
// Voie rapide : faire tourner le processeur un court instant
let spin = 0;
do {
if (Atomics.compareExchange(i32, 0, 0, 1) === 0) {
break;
}
Atomics.pause();
spin++;
} while (spin < 10);
// Voie lente : attendre le verrou
// Cela ne peut être appelé que dans un worker, car le processus
// principal ne peut pas être bloqué
Atomics.wait(i32, 0, 1);
Spécifications
| Spécification |
|---|
| Atomics.pause # Atomics.pause |
Compatibilité des navigateurs
Voir aussi
- L'objet
Atomics - La méthode
Atomics.wait() - La méthode
Atomics.waitAsync()