node中如何具体实现进程间通信的多种方法？

本文共计1657个文字，预计阅读时间需要7分钟。

Node.js 进程间通信方式详解及实现

Node.js 进程间通信（IPC）是构建复杂应用程序的关键。本文将介绍 Node.js 中常见的几种进程间通信方式，并探讨如何在 Node.js 中实现这些通信方式。

通信方式

1. 进程间文件共享

2.管道（Pipe）

3.消息队列（Message Queue）

4.共享内存（Shared Memory）

5.套接字（Socket）

实现方式

以下是在 Node.js 中实现上述通信方式的一些示例：

1. 进程间文件共享

javascript

const fs=require('fs');const { fork }=require('child_process');

const child=fork('child.js');

child.send('Hello from parent');child.on('message', (msg)=> { console.log(`Received message from child: ${msg}`);});

// child.jsprocess.on('message', (msg)=> { console.log(`Received message from parent: ${msg}`); process.send(`Hello from child`);});

2. 管道（Pipe）

javascriptconst { fork }=require('child_process');

const child=fork('child.js');

const { stdin, stdout }=child.stdio;

stdin.write('Hello from parent');stdin.end();

child.on('message', (msg)=> { console.log(`Received message from child: ${msg}`);});

// child.jsprocess.stdin.on('data', (data)=> { console.log(`Received data from parent: ${data}`); process.stdout.write(`Hello from child`);});

3. 消息队列（Message Queue）

javascriptconst { Worker, isMainThread, parent, workerData }=require('worker_threads');

if (isMainThread) { const worker=new Worker('worker.js', { workerData: 'Hello from parent' }); worker.on('message', (msg)=> { console.log(`Received message from worker: ${msg}`); });} else { console.log(`Received data from main thread: ${workerData}`); process.send('Hello from worker');}

// worker.jsprocess.on('message', (msg)=> { console.log(`Received message from main thread: ${msg}`); process.send(`Hello from worker`);});

4. 共享内存（Shared Memory）

javascriptconst { SharedArrayBuffer }=require('buffer');const { worker_threads }=require('worker_threads');

const buffer=new SharedArrayBuffer(1024);const uint32=new Uint32Array(buffer);

if (isMainThread) { uint32[0]=42; const worker=new worker_threads.Worker('worker.js'); worker.on('message', (msg)=> { console.log(`Received message from worker: ${msg}`); });} else { console.log(`Received value from main thread: ${uint32[0]}`); process.send(uint32[0]);}

// worker.jsprocess.on('message', (msg)=> { console.log(`Received message from main thread: ${msg}`); process.send(`Received value: ${msg}`);});

5. 套接字（Socket）

javascriptconst net=require('net');

const server=net.createServer((socket)=> { socket.write('Hello from server'); socket.end();});

server.listen(8000, ()=> { console.log('Server listening on port 8000');});

const client=net.connect({ port: 8000 }, ()=> { console.log('Connected to server'); client.write('Hello from client'); client.end();});

希望这些信息能对您有所帮助！

node进程间如何通信？下面本篇文章带大家了解node进程的通信方式，以及在node中如何实现这些方式的通信，希望对大家有所帮助！

通信其实涵盖开发的各个层面，常见的有客户端和服务端通过各种通信协议进行通信，RPC通信，开发过程中各个模块之间的相互通信，electron主进程和渲染进程之间的通信等等;

本文主要是尝试总结下nodejs(单线程，多线程，多进程)通信的方式，使用场景，实现等。

通信的实现方式

一般进程通信的实现方式如下：

1、Shared Memory(内存共享);

2、Socket(套接字);

3、管道(非命名管道Pipe, 命名管道FIFO);

4、Signal(信号);

5、Message queue(消息队列);

下面我们看下在node中如何实现这些方式的通信

一、Shared Memory(内存共享)

单机下(客户端内单线程，单进程里多线程，单台服务器内多进程)，通过内存共享实现通信的方式最为常见。

Shared Memory(内存共享)-单线程

从操作系统层面来看，进程内所有线程内存都是共享的，但前提是需要知道内存的访问地址。

但从语言层面(node或者说是v8的实现层面)，我们没有直接接触内存的管理，而是间接从v8提供的语法/api进行内存操作。v8提供三种方式给我们共享内存(也许叫共享变量更恰当)：全局变量, 局部变量, 共享传参(call by sharing);

v8在执行代码之前会先将代码通过Estree规范转化为抽象语法树后再进行解释编译执行，在抽象语法树中(关于抽象语法树可查看我另外一篇文章)是有scope的，而内存读取是通过标志符(变量命名)逐级往上回溯查找。所以如果你需要在两个方法之间共享某个内存，可以在他们共同的作用域下进行创建。

Shared Memory(内存共享)-多线程

在客户端环境或node环境，我们都可以实现多线程,两者方式也类似(node通过worker_threads实现，浏览器通过Worker实现)。这里的内存共享主要是借助内存操作的api(SharedArrayBuffer)实现的。先看下浏览器实现的例子:

// 主线程 const buffer = new SharedArrayBuffer(1024) const typedArr = new Int16Array(buffer) const newWorker = new Worker('./worker.js') typedArr[0] = 20 newWorker.postMessage(buffer) newWorker.onmessage= (data) => { console.group('[the main thread]'); console.log('Data received from the main thread: %i', typedArr[0]); console.groupEnd(); } // 子线程 addEventListener('message', ({ data }) => { const arr = new Int16Array(data) console.group('[the worker thread]') console.log('Data received from the main thread: %i', arr[0]) console.groupEnd() arr[0] = 18 postMessage('Updated') }) // 结果 [the worker thread] Data received from the main thread: 20 [the main thread] Data received from the main thread: 18Shared Memory(内存共享)-多进程

因为进程启动后内存是无法相互读取的(系统层面的限制)，进程之间的内存共享实际是通过新开辟一段shared memory实现的。但node暂时没有支持shared memory，只能通过低级语言来实现，例如: c++实现的 shared-memory-disruptor addon插件(另外文章介绍)。

二、Socket(套接字)

Socket 分两种实现：
1、TCP Socket;
2、UNIX Domain Socket;
两者的主要区别如下：

TCP Socket适用于单机,C/S架构等.但UNIX Domain Socket只适用于单机。 UNIX Domain Socket不需要经过一系列的网络中转(协议，分包，校验等等)，性能更高，稳定性更好。TCP Socket

概念: TCP Socket是应用层与TCP/IP协议族通信的中间抽象层,是一种操作系统提供的进程间通信机制;

TCP Socket通信应该是我们日常开发(C/S架构)中最常见的通信方式之一，在我们日常开发中最常见的就是各种应用层协议(stackoverflow.com/questions/11750041/how-to-create-a-named-pipe-in-node-js）
目前理解的管道通信和UNIX Domain Socket实现基本一致，只是管道通信规范了读写权限，半双工通信，UNIX Domain Socket更加自由一些。

四、Signal(信号)

Signal是操作系统在终止进程前给进程发送的信号。在node中可以通过process.kill(pid, signal)/child_process.kill(pid, signal)接口实现,e.g.

// 要被终止的blog.csdn.net/houjixin/article/details/71430489)

但这里的前提是你需要获取到被终止的进程pid，更多pid的内容可阅读我之前关于进程的文章。

五、Message queue(消息队列)

一开始我以为是redis,各种MQ之类的基于TCP的消息队列。但其实是操作系统内的消息队列，node暂时没有提供相关的上层接口，需要更底层实现，e.g. svmq

更多node相关知识，请访问：nodejs 教程！！