Node.js通过SharedArrayBuffer实现线程间共享内存，通过N-API调用C/C++代码实现跨进程共享内存。前者适用于同一进程内worker_threads间高效通信，后者借助操作系统API实现多进程间数据共享，但需处理同步与跨平台问题。
Node.js本身并不像C/C++那样直接提供操作系统级别的共享内存API。它主要通过两种方式实现类似或真实的共享内存功能：一是利用
worker_threads模块中的
SharedArrayBuffer实现进程内的内存共享，这更像是线程间的共享；二是通过N-API（Native Addons）调用底层的C/C++代码来直接访问操作系统提供的共享内存机制，实现跨进程的内存共享。在JavaScript运行时直接进行原始的内存操作是不被允许的，这主要是出于安全性和内存管理（如垃圾回收）的考量。
解决方案
在Node.js中处理共享内存，我们通常会根据“共享”的范围来选择不同的策略。
对于进程内部（即同一个Node.js应用的不同工作线程之间）的数据共享，
SharedArrayBuffer是目前最直接、也是Node.js官方推荐的方式。它允许在不同的
worker_threads之间共享同一块内存区域，并且通过
Atomics对象来保证操作的原子性，避免数据竞争。这在需要高性能并发计算，并且数据量较大、不适合通过消息传递的场景下非常有用。
而对于跨进程（比如一个Node.js进程与其他Node.js进程，或者Node.js进程与C/C++、Python等其他语言进程）的共享内存，情况就复杂一些了。Node.js核心库并没有直接暴露操作系统级别的共享内存接口。这时，最可靠且性能最好的方法是编写一个N-API（Native Addon）模块。通过N-API，我们可以用C/C++代码直接调用操作系统提供的共享内存API（如POSIX系统上的
shm_open、
mmap，或Windows上的
CreateFileMapping、
MapViewOfFile），然后将这些功能封装成JavaScript可调用的接口。这样，Node.js应用就能间接地实现跨进程的共享内存操作了。此外，文件映射（File-backed Memory Maps）也是一种常见的“伪共享内存”方案，Node.js可以通过N-API或一些第三方库来操作文件句柄，实现内存映射。
为什么Node.js直接操作共享内存会比较复杂？
在我看来，Node.js在设计之初就不是为了直接进行底层内存操作而生的。它的核心是基于V8引擎的JavaScript运行时，而JavaScript本身是一种高级语言，抽象掉了大部分内存管理的细节，例如垃圾回收机制就是其核心特性之一。这意味着开发者通常不需要关心内存分配和释放，这大大简化了开发。
但这种便利也带来了限制。JavaScript的内存模型是高度抽象和受保护的，它没有直接的指针概念，也不允许直接访问物理内存地址。V8引擎为了保证内存安全和垃圾回收的效率，会对JavaScript对象进行移动和压缩。如果Node.js允许直接操作共享内存，那么这种直接访问可能会与V8的垃圾回收机制产生冲突，导致内存损坏或安全漏洞。
此外，Node.js的单线程事件循环模型也是一个重要因素。虽然
worker_threads引入了多线程，但其设计哲学依然强调通过消息传递来协调不同线程之间的工作，而不是让它们自由地共享和修改内存。
SharedArrayBuffer是一个例外，但它也需要配合
Atomics来确保数据一致性，这本身就说明了直接共享内存的复杂性。坦白说，这种设计理念是为了提供一个更安全、更易于理解和调试的并发模型，避免了传统多线程编程中常见的竞态条件和死锁问题。
如何在Node.js中使用SharedArrayBuffer实现进程内共享？
SharedArrayBuffer是Node.js中实现同一个进程内不同
worker_threads之间共享内存的关键。它不像普通的
ArrayBuffer，在传递给Worker时会进行复制，
SharedArrayBuffer是真正地在主线程和Worker线程之间共享同一块内存区域。
使用它的基本步骤是：
- 在主线程或一个Worker线程中创建一个
SharedArrayBuffer
实例。 - 将这个
SharedArrayBuffer
实例通过worker.postMessage()
传递给其他Worker线程。由于它是共享的，传递的是引用而非拷贝。 - 在所有拥有该
SharedArrayBuffer
引用的线程中，都可以通过Int32Array
、Uint8Array
等类型化数组视图来读写这块共享内存。 -
关键点： 由于多个线程可能同时读写同一块内存，为了避免数据不一致和竞态条件，必须使用
Atomics
对象提供的原子操作方法（如Atomics.add()
,Atomics.load()
,Atomics.store()
,Atomics.compareExchange()
等）来对共享内存进行操作。
下面是一个简单的例子：
// main.js (主线程)
const { Worker, isMainThread, parentPort } = require('worker_threads');
if (isMainThread) {
// 创建一个1KB的共享内存缓冲区
const sharedBuffer = new SharedArrayBuffer(1024);
const sharedArray = new Int32Array(sharedBuffer);
// 初始化共享内存的第一个元素
sharedArray[0] = 0;
console.log('主线程：初始值 =', sharedArray[0]);
// 启动两个Worker
const worker1 = new Worker(__filename);
const worker2 = new Worker(__filename);
// 将共享缓冲区传递给Worker
worker1.postMessage({ sharedBuffer });
worker2.postMessage({ sharedBuffer });
let completedWorkers = 0;
worker1.on('message', (msg) => {
if (msg === 'done') {
completedWorkers++;
if (completedWorkers === 2) {
console.log('主线程：所有Worker完成，最终值 =', sharedArray[0]);
}
}
});
worker2.on('message', (msg) => {
if (msg === 'done') {
completedWorkers++;
if (completedWorkers === 2) {
console.log('主线程：所有Worker完成，最终值 =', sharedArray[0]);
}
}
});
} else {
// worker.js (工作线程)
parentPort.on('message', (msg) => {
const { sharedBuffer } = msg;
const sharedArray = new Int32Array(sharedBuffer);
// 每个Worker对共享内存的第一个元素进行1000次原子加操作
for (let i = 0; i < 1000; i++) {
Atomics.add(sharedArray, 0, 1); // 原子加操作
}
parentPort.postMessage('done');
});
}运行这段代码，你会看到最终
sharedArray[0]的值是2000，这证明了两个Worker成功地共享并原子性地修改了同一块内存区域。
Node.js如何通过N-API与C/C++共享内存进行交互？
当我们需要在Node.js进程和其他独立的进程（无论是不是Node.js进程）之间共享内存时，N-API就成了我们的桥梁。N-API允许我们编写C/C++代码，并将其编译成一个Node.js可以加载的模块。在C/C++代码中，我们可以直接使用操作系统提供的低级共享内存API。
这个过程大致是这样的：
-
C/C++模块开发：
- 在C/C++中，你需要使用平台特定的API来创建或打开共享内存区域。
- 在POSIX系统（Linux, macOS等）上，这通常涉及到
shm_open()
来创建或打开一个共享内存对象，然后使用ftruncate()
设置其大小，最后用mmap()
将这个共享内存对象映射到进程的地址空间。 - 在Windows系统上，你需要使用
CreateFileMapping()
来创建一个文件映射对象，然后用MapViewOfFile()
将它映射到进程的地址空间。
- 在POSIX系统（Linux, macOS等）上，这通常涉及到
- C/C++代码会提供函数来读写这块共享内存。
- 使用N-API的宏和函数，将这些C/C++函数封装成JavaScript可以调用的函数，并注册到Node.js模块中。例如，你可能会暴露一个
createSharedMemory()
函数来创建共享内存，一个getSharedMemoryBuffer()
函数来返回一个指向共享内存的ArrayBuffer
，以及writeToSharedMemory()
、readFromSharedMemory()
等函数。
- 在C/C++中，你需要使用平台特定的API来创建或打开共享内存区域。
-
Node.js应用调用：
- 在Node.js应用中，你通过
require()
加载这个编译好的N-API模块。 - 然后，你就可以像调用普通的JavaScript函数一样，调用C/C++暴露出来的共享内存操作函数了。例如，
const mySharedMem = require('./build/Release/shared_mem_addon');，然后调用mySharedMem.createSharedMemory('my_shm_key', 4096);。
- 在Node.js应用中，你通过
概念性代码示例（简化版，仅展示思路）：
C++部分 (shared_mem_addon.cc
)：
#include <napi.h>
#include <iostream>
#include <string>
#include <vector>
#ifdef _WIN32
#include <windows.h>
#else
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#endif
// 这是一个非常简化的示例，实际生产环境需要更健壮的错误处理和资源管理
void* shared_memory_ptr = nullptr;
size_t shared_memory_size = 0;
#ifdef _WIN32
HANDLE hMapFile = NULL;
#else
int shm_fd = -1;
#endif
Napi::Value CreateSharedMemory(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
if (info.Length() < 2 || !info[0].IsString() || !info[1].IsNumber()) {
Napi::TypeError::New(env, "Expected shared memory key (string) and size (number)").ThrowAsJavaScriptException();
return env.Null();
}
std::string key = info[0].As<Napi::String>().Utf8Value();
shared_memory_size = info[1].As<Napi::Number>().Uint32Value();
#ifdef _WIN32
hMapFile = CreateFileMapping(
INVALID_HANDLE_VALUE, // use paging file
NULL, // default security
PAGE_READWRITE, // read/write access
0, // maximum object size (high-order DWORD)
shared_memory_size, // maximum object size (low-order DWORD)
key.c_str()); // name of mapping object
if (hMapFile == NULL) {
Napi::Error::New(env, "Could not create file mapping object").ThrowAsJavaScriptException();
return env.Null();
}
shared_memory_ptr = MapViewOfFile(
hMapFile, // handle to map object
FILE_MAP_ALL_ACCESS, // read/write access
0,
0,
shared_memory_size);
if (shared_memory_ptr == NULL) {
CloseHandle(hMapFile);
Napi::Error::New(env, "Could not map view of file").ThrowAsJavaScriptException();
return env.Null();
}
#else // POSIX
shm_fd = shm_open(key.c_str(), O_CREAT | O_RDWR, 0666);
if (shm_fd == -1) {
Napi::Error::New(env, "shm_open failed").ThrowAsJavaScriptException();
return env.Null();
}
if (ftruncate(shm_fd, shared_memory_size) == -1) {
close(shm_fd);
Napi::Error::New(env, "ftruncate failed").ThrowAsJavaScriptException();
return env.Null();
}
shared_memory_ptr = mmap(0, shared_memory_size, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
if (shared_memory_ptr == MAP_FAILED) {
close(shm_fd);
Napi::Error::New(env, "mmap failed").ThrowAsJavaScriptException();
return env.Null();
}
#endif
return Napi::Boolean::New(env, true);
}
Napi::Value GetSharedMemoryBuffer(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
if (shared_memory_ptr == nullptr) {
Napi::Error::New(env, "Shared memory not initialized").ThrowAsJavaScriptException();
return env.Null();
}
// N-API允许从原生内存创建ArrayBuffer
return Napi::ArrayBuffer::New(env, shared_memory_ptr, shared_memory_size);
}
// 在模块卸载时清理资源
Napi::Object Init(Napi::Env env, Napi::Object exports) {
exports.Set(Napi::String::New(env, "createSharedMemory"), Napi::Function::New(env, CreateSharedMemory));
exports.Set(Napi::String::New(env, "getSharedMemoryBuffer"), Napi::Function::New(env, GetSharedMemoryBuffer));
return exports;
}
NODE_API_MODULE(shared_mem_addon, Init)Node.js调用部分 (app.js
)：
// app.js
const sharedMemAddon = require('./build/Release/shared_mem_addon'); // 假设已编译好
const SHM_KEY = 'my_unique_shm_key';
const SHM_SIZE = 1024; // 1KB
try {
// 创建或连接共享内存
const created = sharedMemAddon.createSharedMemory(SHM_KEY, SHM_SIZE);
console.log(`共享内存 ${SHM_KEY} ${created ? '创建/连接成功' : '失败'}`);
// 获取共享内存的ArrayBuffer视图
const sharedBuffer = sharedMemAddon.getSharedMemoryBuffer();
const uint8Array = new Uint8Array(sharedBuffer);
// 写入数据
const message = "Hello from Node.js!";
for (let i = 0; i < message.length; i++) {
uint8Array[i] = message.charCodeAt(i);
}
uint8Array[message.length] = 0; // null terminator
console.log('Node.js写入数据:', message);
// 假设有另一个进程（可能是另一个Node.js进程或C++程序）
// 也能通过相同的SHM_KEY连接到这块共享内存并读取数据。
// ...
// 在真实场景中，这里还需要一个机制来同步读写，比如信号量或互斥锁，
// 同样可以在C++ addon中实现并暴露给JS。
} catch (error) {
console.error('操作共享内存失败:', error.message);
}
// 注意：共享内存的清理（如shm_unlink或UnmapViewOfFile/CloseHandle）
// 同样需要通过N-API在C++中实现并由Node.js调用，
// 或者在进程退出时自动清理（依赖OS行为）。通过N-API，Node.js获得了直接与操作系统底层交互的能力，从而能够实现真正的跨进程共享内存。但这种方法会显著增加项目的复杂性，因为它引入了C/C++开发、编译、以及跨平台兼容性等问题。此外，共享内存本身也需要细致的同步机制（如信号量、互斥锁）来避免数据损坏，这些也需要在C/C++层面实现。所以，通常只在对性能有极高要求，且其他IPC方式无法满足的特定场景下才会考虑使用N-API来实现共享内存。
