L'objet de l'espace de nomsAtomics contient des méthodes statiques permettant d'effectuer des opérations atomiques. Elles sont utilisées avec les objetsSharedArrayBuffer etArrayBuffer.

Description

Contrairement à la plupart des objets globaux,Atomics n'est pas un constructeur. Vous ne pouvez pas l'utiliser avec l'opérateurnew ni invoquer l'objetAtomics comme une fonction. Toutes les propriétés et méthodes deAtomics sont statiques (tout comme l'objetMath).

Opérations atomiques

Lorsque la mémoire est partagée, plusieurs processus peuvent lire et écrire les mêmes données en mémoire. Les opérations atomiques garantissent que des valeurs prévisibles sont écrites et lues, que les opérations sont terminées avant que l'opération suivante ne commence et que les opérations ne sont pas interrompues.

Attente et notification

Les méthodeswait() etnotify() sont modélisées sur les futex Linux « fast user-space mutex » et fournissent des moyens d'attendre jusqu'à ce qu'une certaine condition devienne vraie et sont généralement utilisées comme constructions bloquantes.

Propriétés statiques

Atomics[Symbol.toStringTag]

La valeur initiale de la propriété[Symbol.toStringTag] est la chaîne « Atomics ». Cette propriété est utilisée dansObject.prototype.toString().

Méthodes statiques

Atomics.add()

Ajoute la valeur fournie à la valeur existante à l'index défini du tableau. Retourne l'ancienne valeur à cet index.

Atomics.and()

Calcule un « ET » binaire entre la valeur à l'index défini du tableau et la valeur fournie. Retourne l'ancienne valeur à cet index.

Atomics.compareExchange()

Stocke la valeur fournie à l'index défini du tableau si elle est égale à une valeur donnée. Retourne l'ancienne valeur.

Atomics.exchange()

Stocke la valeur fournie à l'index défini du tableau. Retourne l'ancienne valeur.

Atomics.isLockFree()

Primitive d'optimisation permettant de déterminer s'il faut utiliser des verrous ou des opérations atomiques. Retournetrue si une opération atomique sur des tableaux de la taille d'élément donnée sera implémentée par une opération atomique matérielle (plutôt que par un verrou). Réservé aux expert·e·s.

Atomics.load()

Retourne la valeur à l'index défini du tableau.

Atomics.notify()

Notifie les agents qui attendent sur l'index défini du tableau. Retourne le nombre d'agents notifiés.

Atomics.or()

Calcule un « OU » binaire entre la valeur à l'index défini du tableau et la valeur fournie. Retourne l'ancienne valeur à cet index.

Atomics.pause()

Fournit une primitive de micro-attente qui indique au processeur que l'appelant effectue une boucle d'attente 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) ou au processus, sans céder l'exécution du processus courant.

Atomics.store()

Stocke une valeur à l'index défini du tableau. Retourne la valeur.

Atomics.sub()

Soustrait une valeur à l'index défini du tableau. Retourne l'ancienne valeur à cet index.

Atomics.wait()

Vérifie que l'index défini du tableau contient toujours une valeur puis dort en attendant ou expire. Retourne soit"ok","not-equal" ou"timed-out". Si l'attente n'est pas autorisée dans l'agent appelant, cela lève une exception. (La plupart des navigateurs n'autoriseront paswait() sur le processus principal du navigateur.)

Atomics.waitAsync()

Attend de manière asynchrone (c'est‑à‑dire sans bloquer, contrairement àAtomics.wait) sur une zone de mémoire partagée et retourne un objet représentant le résultat de l'opération.

Atomics.xor()

Calcule un « OU » exclusif binaire entre la valeur à l'index défini du tableau et la valeur fournie. Retourne l'ancienne valeur à cet index.

Exemples

Notez que ces exemples ne peuvent pas être exécutés directement depuis la console ou une page web arbitraire, carSharedArrayBuffer n'est pas défini à moins queses exigences de sécurité ne soient respectées.

UtiliserAtomics

const sab = new SharedArrayBuffer(1024);const ta = new Uint8Array(sab);ta[0]; // 0ta[0] = 5; // 5Atomics.add(ta, 0, 12); // 5Atomics.load(ta, 0); // 17Atomics.and(ta, 0, 1); // 17Atomics.load(ta, 0); // 1Atomics.compareExchange(ta, 0, 5, 12); // 1Atomics.load(ta, 0); // 1Atomics.exchange(ta, 0, 12); // 1Atomics.load(ta, 0); // 12Atomics.isLockFree(1); // trueAtomics.isLockFree(2); // trueAtomics.isLockFree(3); // falseAtomics.isLockFree(4); // trueAtomics.or(ta, 0, 1); // 12Atomics.load(ta, 0); // 13Atomics.store(ta, 0, 12); // 12Atomics.sub(ta, 0, 2); // 12Atomics.load(ta, 0); // 10Atomics.xor(ta, 0, 1); // 10Atomics.load(ta, 0); // 11

Attente et notification

Étant donné unInt32Array partagé :

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

Un processus de lecture est en sommeil et attend sur l'index 0 parce que la valeur fournie correspond à celle stockée à l'index fourni.Le processus de lecture ne poursuivra pas son exécution tant que le processus d'écriture n'aura pas appeléAtomics.notify() à la position 0 du tableau typé fourni.Notez que si, après avoir été réveillé, la valeur de l'index 0 n'a pas été modifiée par le processus d'écriture, le processus de lecture ne se remettrapas à dormir, mais continuera son exécution.

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

Un processus d'écriture stocke une nouvelle valeur et notifie le processus en attente une fois qu'il a écrit :

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

Spécifications

Compatibilité des navigateurs

Voir aussi

• L'objetArrayBuffer
• Guidedes tableaux typés en JavaScript
• Web Workers
• La mémoire partagée — un rapide tutoriel^(angl.) dans la proposition TC39 ecmascript-sharedmem
• Aperçu des nouvelles primitives parallèles de JavaScript^(angl.) sur hacks.mozilla.org (2016)