Node.js 多线程编程：Atomics.store() 和 Atomics.load() 避坑指南，告别数据竞争

Node.js 多线程编程：Atomics.store() 和 Atomics.load() 避坑指南，告别数据竞争

你好，我是你的老朋友“代码老炮儿”。

在 Node.js 的世界里，随着 worker_threads 模块的日益成熟，多线程编程已经不再是“屠龙之技”。越来越多的开发者开始利用多线程来提升应用的性能，尤其是在处理 CPU 密集型任务时。但多线程编程就像一把双刃剑，在带来性能提升的同时，也带来了数据竞争、内存一致性等一系列问题。今天，咱们就来聊聊 Node.js 中用于解决这些问题的利器——Atomics 对象，特别是其中的 Atomics.store() 和 Atomics.load() 方法。

为什么需要 Atomics？

在单线程环境下，JavaScript 的执行是顺序的，我们不用担心多个操作同时修改同一个变量。但在多线程环境下，情况就复杂了。多个线程可能同时访问和修改共享内存中的数据，如果没有适当的同步机制，就会导致数据竞争，最终结果不可预测。

想象一下，你和你的同事同时修改同一个文档，如果没有版本控制，最终的文档很可能是一团糟。Atomics 对象就是 JavaScript 多线程编程中的“版本控制系统”，它提供了一组原子操作，确保对共享内存的读写操作是“原子”的，即不可分割的，要么全部完成，要么全部不完成，不会出现中间状态。

Atomics.store() 和 Atomics.load()：原子存储和加载

Atomics.store() 和 Atomics.load() 是 Atomics 对象中最常用的两个方法，它们分别用于原子地存储和加载共享内存中的数据。

Atomics.store(typedArray, index, value)

• typedArray：共享的类型化数组（SharedArrayBuffer 对应的类型化数组，如 Int32Array）。
• index：要存储的元素在 typedArray 中的索引。
• value：要存储的值。

Atomics.store() 方法将 value 原子地存储到 typedArray 的 index 位置。这意味着，即使其他线程同时尝试修改同一位置的值，Atomics.store() 也能保证只有一个线程的操作会成功，其他线程的操作会被阻塞，直到当前操作完成。

Atomics.load(typedArray, index)

• typedArray：共享的类型化数组。
• index：要加载的元素在 typedArray 中的索引。

Atomics.load() 方法原子地从 typedArray 的 index 位置加载值。它保证读取到的是最新的值，即使其他线程正在同时修改这个值。

实战案例：多线程计数器

为了更好地理解 Atomics.store() 和 Atomics.load() 的用法，我们来看一个多线程计数器的例子。假设我们需要一个计数器，多个线程可以同时对它进行递增操作。

// counter.js
const { Worker, isMainThread, parentPort, workerData } = require('worker_threads');
const { Buffer } = require('node:buffer');
 
if (isMainThread) {
  // 主线程
  const sharedBuffer = new SharedArrayBuffer(4); // 创建一个 4 字节的 SharedArrayBuffer
  const sharedArray = new Int32Array(sharedBuffer); // 创建一个 Int32Array 视图
 
  const numWorkers = 4;
  for (let i = 0; i < numWorkers; i++) {
    new Worker(__filename, { workerData: { sharedBuffer } });
  }
 
  // 等待一段时间，让子线程完成计数
  setTimeout(() => {
    console.log('Final count:', Atomics.load(sharedArray, 0)); // 原子地读取计数器的值
  }, 1000);
} else {
  // 子线程
  const sharedArray = new Int32Array(workerData.sharedBuffer);
 
  // 每个子线程递增 100000 次
  for (let i = 0; i < 100000; i++) {
    Atomics.store(sharedArray, 0, Atomics.load(sharedArray, 0) + 1); // 原子地递增计数器
    //  也可以使用 Atomics.add(sharedArray, 0, 1); //原子添加操作
  }
 
  parentPort.postMessage('done');
}

在这个例子中，我们创建了一个 SharedArrayBuffer，并在主线程和子线程之间共享它。每个子线程都对共享数组中的第一个元素（索引为 0）进行 100000 次递增操作。我们使用 Atomics.store() 和 Atomics.load() 来保证递增操作的原子性。

如果不使用 Atomics，而是直接使用 sharedArray[0]++，那么最终的计数结果很可能小于 400000，因为多个线程同时读取和修改 sharedArray[0] 会导致数据竞争。

常见问题和注意事项

1. 只能用于 SharedArrayBuffer：Atomics 对象的方法只能用于操作 SharedArrayBuffer 对应的类型化数组，不能用于普通的数组。

2. 类型化数组的类型：Atomics 对象支持多种类型化数组，如 Int8Array、Uint8Array、Int16Array、Uint16Array、Int32Array、Uint32Array、BigInt64Array、BigUint64Array。选择哪种类型取决于你的数据范围和需求。

3. 性能考虑：虽然 Atomics 操作是原子的，但它们比普通的数组操作要慢。因为原子操作需要进行额外的同步和内存屏障，以保证数据的一致性。因此，只有在必要时才应该使用 Atomics，不要滥用。

4. Atomics.wait() 和 Atomics.notify(): 除了store()和load(), 还有Atomics.wait() 和 Atomics.notify() 用于线程间的同步和通信。 Atomics.wait() 会阻塞当前线程，直到共享内存中的某个条件满足。Atomics.notify() 用于唤醒等待在共享内存上的线程。

5. 内存模型: 理解JavaScript的内存模型对于正确使用Atomics至关重要. 主要是理解“happens-before”关系. 例如，在一个线程中使用Atomics.store()存储一个值，然后在另一个线程中使用Atomics.load()加载这个值，那么store操作“happens-before”load操作，保证了load操作能看到store操作写入的值。

6. 死锁: 不正确的使用Atomics.wait()和Atomics.notify()可能导致死锁。例如, 如果所有线程都在等待一个永远不会发生的条件, 那么这些线程将永远阻塞。

深入思考：Atomics 的局限性

Atomics 对象虽然提供了原子操作，但它并不能解决所有多线程编程中的问题。它主要用于处理基本数据类型（如整数、浮点数）的原子操作，对于复杂的数据结构（如对象、数组）的并发访问，Atomics 就无能为力了。对于复杂数据结构的并发访问，你可能需要使用更高级的同步机制，如互斥锁（Mutex）、读写锁（ReadWriteLock）等。Node.js 社区已经有一些相关的模块，例如 async-mutex，可以帮助你实现这些同步机制。但是请注意这些模块一般基于Atomics实现, 需要仔细考虑其适用场景。

总结

Atomics 对象是 Node.js 多线程编程中不可或缺的一部分，它提供了一组原子操作，可以有效地避免数据竞争和内存一致性问题。Atomics.store() 和 Atomics.load() 是其中最常用的两个方法，分别用于原子地存储和加载共享内存中的数据。但是，Atomics 也有其局限性，它主要用于处理基本数据类型的原子操作，对于复杂数据结构的并发访问，你可能需要使用更高级的同步机制。

希望通过今天的分享，你能对 Atomics.store() 和 Atomics.load() 有更深入的理解，并在实际开发中正确地使用它们。记住，多线程编程是一项复杂的任务，需要仔细的设计和谨慎的实现。在享受多线程带来的性能提升的同时，也要时刻警惕数据竞争和内存一致性问题。如果你在使用中遇到任何疑问，欢迎随时向我提问，“代码老炮儿”随时为你解答。