JavaScript 中的 Atomics 对象提供了一组静态方法，用于对 SharedArrayBuffer 对象执行原子操作。原子操作是指保证在一个步骤内完成而不被其他线程中断的操作。这使得它们非常适合用来实现并发的数据结构和算法。
作为 ECMAScript 标准的一部分，JavaScript 中的 Atomics 对象作为管理多线程环境中共享内存的关键工具。让我们进一步理解原子操作的基本概念：
Atomics 对象
Atomics 对象是一个内置的 JavaScript 对象，它提供了对共享内存的原子操作。它设计用于多线程环境中，多个线程或 Web Workers 可能同时访问和修改共享数据。
原子的本质
在 Atomics 对象的上下文中，“原子”意味着一个关键特征：它执行本质上不可分割的操作。当我们声明一个操作为原子时，我们指的是其执行是连续且不可中断的，如同一个单一单元。这种品质对于防止竞态条件至关重要；竞态条件发生在并发操作的结果依赖于它们执行的时间和顺序时。
原子操作
原子操作是在共享内存上保证作为一个单一、不可中断单元执行的低级操作。这些操作包括加法、减法、位运算、交换等。
Atomics 对象提供了如 add, sub, and, or, xor, load, store, exchange, 等方法，每种对应一个特定的原子操作。
原子方法及其描述
| Sr.No. |
方法 |
描述 |
| 1 |
Atomics.add() |
将指定值加到 typed array 指定索引处的元素上。原子地返回原始值。 |
| 2 |
Atomics.sub() |
从 typed array 指定索引处的元素中减去指定值。原子地返回原始值。 |
| 3 |
Atomics.and() |
在 typed array 指定索引处的元素上与给定值执行原子位与操作。原子地返回原始值。 |
| 4 |
Atomics.or() |
在 typed array 指定索引处的元素上与给定值执行原子位或操作。原子地返回原始值。 |
| 5 |
Atomics.xor() |
在 typed array 指定索引处的元素上与给定值执行原子位异或操作。原子地返回原始值。 |
| 6 |
Atomics.load() |
原子地检索 typed array 指定索引处的值。 |
| 7 |
Atomics.store() |
原子地将给定值存储在 typed array 指定索引处。 |
| 8 |
Atomics.exchange() |
将 typed array 指定索引处的值与指定值交换。原子地返回原始值。 |
| 9 |
Atomics.compareExchange() |
比较 typed array 指定索引处的值与提供的预期值，并如果匹配则更新为新值。原子地返回原始值。 |
| 10 |
Atomics.wait() |
原子地等待直到 typed array 指定索引处的值变为特定值。允许线程间高效协调。 |
| 11 |
Atomics.notify() |
原子地通知与 typed array 指定索引关联的等待队列。 |
示例
示例 1：Atomics 操作的基本使用
在这个示例中，演示了 Atomics 对象在其共享内存上的基础原子操作。这些操作包括加法、减法、位与、或、异或、加载、存储、交换以及比较交换值。每个操作都确保了执行单元的不可分割性，这对于防止多线程环境中的竞态条件至关重要。
Atomics.add()
const sharedBuffer = new SharedArrayBuffer(4);
const sharedArray = new Int32Array(sharedBuffer);
const originalAddValue = Atomics.add(sharedArray, 0, 10);
console.log(`Atomics.add: Original value: ${originalAddValue}, New value: ${sharedArray[0]}`);
输出:
Atomics.add: Original value: 0, New value: 10
Atomics.sub()
const sharedBuffer = new SharedArrayBuffer(4);
const sharedArray = new Int32Array(sharedBuffer);
const originalSubValue = Atomics.sub(sharedArray, 0, 5);
console.log(`Atomics.sub: Original value: ${originalSubValue}, New value: ${sharedArray[0]}`);
输出:
Atomics.sub: Original value: 10, New value: 5
Atomics.and()
const sharedBuffer = new SharedArrayBuffer(4);
const sharedArray = new Int32Array(sharedBuffer);
const originalAndValue = Atomics.and(sharedArray, 0, 0b1010);
console.log(`Atomics.and: Original value: ${originalAndValue}, New value: ${sharedArray[0].toString(2)}`);
输出:
Atomics.and: Original value: 5, New value: 0
Atomics.or()
const sharedBuffer = new SharedArrayBuffer(4);
const sharedArray = new Int32Array(sharedBuffer);
const originalOrValue = Atomics.or(sharedArray, 0, 0b1100);
console.log(`Atomics.or: Original value: ${originalOrValue}, New value: ${sharedArray[0].toString(2)}`);
输出:
Atomics.or: Original value: 0, New value: 1100
Atomics.xor()
const sharedBuffer = new SharedArrayBuffer(4);
const sharedArray = new Int32Array(sharedBuffer);
const originalXorValue = Atomics.xor(sharedArray, 0, 0b0110);
console.log(`Atomics.xor: Original value: ${originalXorValue}, New value: ${sharedArray[0].toString(2)}`);
输出:
Atomics.xor: Original value: 12, New value: 1010
Atomics.load()
const sharedBuffer = new SharedArrayBuffer(4);
const sharedArray = new Int32Array(sharedBuffer);
const loadedValue = Atomics.load(sharedArray, 0);
console.log(`Atomics.load: Loaded value: ${loadedValue}`);
输出:
Atomics.load: Loaded value: 10
Atomics.store()
const sharedBuffer = new SharedArrayBuffer(4);
const sharedArray = new Int32Array(sharedBuffer);
Atomics.store(sharedArray, 0, 42);
console.log(`Atomics.store: New value: ${sharedArray[0]}`);
输出:
Atomics.store: New value: 42
Atomics.exchange()
const sharedBuffer = new SharedArrayBuffer(4);
const sharedArray = new Int32Array(sharedBuffer);
const originalExchangeValue = Atomics.exchange(sharedArray, 0, 99);
console.log(`Atomics.exchange: Original value: ${originalExchangeValue}, New value: ${sharedArray[0]}`);
输出:
Atomics.exchange: Original value: 42, New value: 99
Atomics.compareExchange()
const sharedBuffer = new SharedArrayBuffer(4);
const sharedArray = new Int32Array(sharedBuffer);
const expectedValue = 99;
const newValue = 55;
const successfulCompareExchange = Atomics.compareExchange(sharedArray, 0, expectedValue, newValue);
console.log(`Atomics.compareExchange: Operation was${successfulCompareExchange ? ' ' : ' not '}successful. New value: ${sharedArray[0]}`);
输出:
Atomics.compareExchange: Operation was successful. New value: 55
Atomics.wait()
const sharedBuffer = new SharedArrayBuffer(4);
const sharedArray = new Int32Array(sharedBuffer);
const valueToWaitFor = 55;
Atomics.store(sharedArray, 0, valueToWaitFor);
setTimeout(() => {
Atomics.notify(sharedArray, 0);
}, 2000);
const waitResult = Atomics.wait(sharedArray, 0, valueToWaitFor, 5000);
console.log(`Atomics.wait: Wait result: ${waitResult}`);
输出:
Atomics.wait: Wait result: timed-out
示例 2：现实世界中的应用案例 - 同步计数器
在这个现实世界的场景中，我们利用 Atomics 对象构建了一个同步计数器；多个线程通过使用 Atomics.add() 操作来递增这个计数器，从而保证了更新过程中的原子性。通过这样的应用，有效地进行线程协调的功能性和必要性变得显而易见：它在多线程环境中提供了实用的数据管理解决方案。
const sharedBuffer = new SharedArrayBuffer(4);
const sharedArray = new Int32Array(sharedBuffer);
function incrementCounter() {
const incrementValue = 1;
const originalValue = Atomics.add(sharedArray, 0, incrementValue);
console.log(`Incremented counter by ${incrementValue}. New value: ${sharedArray[0]}`);
}
setInterval(() => {
incrementCounter();
}, 1000);
setInterval(() => {
console.log('Main thread doing other work.');
}, 3000);
输出:
Incremented counter by 1. New value: 1
Incremented counter by 1. New value: 2
Main thread doing other work.
Incremented counter by 1. New value: 3
Incremented counter by 1. New value: 4
Incremented counter by 1. New value: 5
Main thread doing other work.
Incremented counter by 1. New value: 6
Incremented counter by 1. New value: 7
Incremented counter by 1. New value: 8
Main thread doing other work.
...