JavaScript - Atomics 原子对象

JavaScript 中的 Atomics 对象提供了一组静态方法，用于对 SharedArrayBuffer 对象执行原子操作。原子操作是指保证在单个步骤中完成，不会被其他线程中断的操作。这使得它们对于实现并发数据结构和算法非常有用。

JavaScript 中的 Atomics 对象是 ECMAScript 标准的一部分，是管理多线程环境中共享内存的重要工具。让我们更详细地了解原子操作的基本概念:

Atomics 对象

Atomics 对象是一个内置的 JavaScript 对象，它提供对共享内存的原子操作。它旨在用于多线程环境，在该环境中，多个线程或 Web Worker 可能并发访问和修改共享数据。

"原子性"的本质

在 Atomics 对象的上下文中，"原子性"表示一个关键特性:它执行的操作本质上是不可分割的。当我们将某个操作声明为原子性时，意味着它的执行像一个单元一样连续且不间断地进行。这种特性对于防止竞争条件至关重要;当并发操作的结果取决于其执行的时间和顺序时，就会出现竞争条件。

原子操作

原子操作是共享内存上的低级操作，保证作为单个、不可中断的单元执行。这些操作包括加法、减法、位运算、交换等等。

Atomics 对象提供了诸如 add、sub、and、or、xor、load、store、exchange 等方法，每个方法都对应一个特定的原子操作。

示例

示例 1:原子操作的基本用法

本例演示了 Atomics 对象在共享内存上的基本原子操作。这些操作包括加法、减法、按位与、或、异或、加载、存储、交换和比较交换值。每个操作都确保执行单元的不可分割性，这对于防止多线程环境中的竞争条件至关重要。

Atomics.add()

// 共享内存设置
const sharedBuffer = new SharedArrayBuffer(4);
const sharedArray = new Int32Array(sharedBuffer);
// Atomics.add()
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.add()

// 共享内存设置
const sharedBuffer = new SharedArrayBuffer(4);
const sharedArray = new Int32Array(sharedBuffer);
// Atomics.sub()
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.add()

// 共享内存设置
const sharedBuffer = new SharedArrayBuffer(4);
const sharedArray = new Int32Array(sharedBuffer);
// Atomics.and()
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);
// Atomics.or()
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);
// Atomics.xor()
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);
// Atomics.load()
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()
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);
// Atomics.exchange()
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);
// Atomics.compareExchange()
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);
// Atomics.wait()
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]}`);
}

// Multiple threads incrementing the counter
setInterval(() => {
  incrementCounter();
}, 1000);

// Simulate other activities in the main thread
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.
...