进程间通信

进程间通信的基本概念

进程间通信（IPC）是操作系统提供的机制，允许不同进程之间交换数据和信息。在Node.js中，IPC尤为重要，因为Node.js采用单线程事件循环模型，需要借助子进程来处理CPU密集型任务。IPC方式包括管道、消息队列、共享内存、信号量和套接字等。Node.js主要通过child_process模块和cluster模块实现IPC。

Node.js中的进程创建

Node.js通过child_process模块创建子进程，主要方法有spawn()、exec()、execFile()和fork()。其中fork()方法专门用于创建Node.js子进程，并自动建立IPC通道。

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

// 创建子进程
const child = fork('child.js');

// 父进程发送消息
child.send({ hello: 'world' });

// 父进程接收消息
child.on('message', (msg) => {
  console.log('父进程收到消息:', msg);
});

对应的子进程文件child.js：

// 子进程接收消息
process.on('message', (msg) => {
  console.log('子进程收到消息:', msg);
  
  // 子进程发送响应
  process.send({ response: '收到' });
});

IPC通信机制

Node.js的IPC通信基于操作系统提供的管道机制实现。当使用fork()创建子进程时，Node.js会在父子进程之间创建一个匿名管道，这个管道是双向的，允许双方互相发送消息。

通信过程特点：

1. 消息会被序列化为JSON格式传输
2. 消息大小受限于操作系统管道缓冲区大小
3. 消息传递是异步非阻塞的
4. 消息顺序得到保证

消息传递的底层实现

Node.js内部使用libuv库处理IPC通信。当调用process.send()时，消息会被序列化并写入IPC通道。接收方通过事件循环监听IPC通道，收到数据后反序列化并触发message事件。

// 底层模拟IPC发送过程
function sendMessage(channel, message) {
  const serialized = JSON.stringify(message);
  const buffer = Buffer.from(serialized);
  
  // 实际写入IPC通道
  channel.write(buffer);
}

高级IPC模式

请求-响应模式

可以实现类似RPC的调用方式：

// parent.js
const { fork } = require('child_process');
const child = fork('child.js');

function callChild(method, args, callback) {
  const id = Date.now();
  
  child.send({
    type: 'request',
    id,
    method,
    args
  });
  
  const listener = (msg) => {
    if (msg.type === 'response' && msg.id === id) {
      child.off('message', listener);
      callback(msg.result);
    }
  };
  
  child.on('message', listener);
}

callChild('add', [1, 2], (result) => {
  console.log('1 + 2 =', result);
});

// child.js
process.on('message', (msg) => {
  if (msg.type === 'request') {
    let result;
    switch(msg.method) {
      case 'add':
        result = msg.args[0] + msg.args[1];
        break;
      // 其他方法...
    }
    
    process.send({
      type: 'response',
      id: msg.id,
      result
    });
  }
});

流式数据传输

对于大数据传输，可以使用流式处理：

// parent.js
const { fork } = require('child_process');
const child = fork('child.js');
const fs = require('fs');

const largeFile = fs.createReadStream('large-file.txt');

largeFile.on('data', (chunk) => {
  child.send({
    type: 'data',
    chunk: chunk.toString('base64')
  });
});

largeFile.on('end', () => {
  child.send({ type: 'end' });
});

// child.js
let content = '';

process.on('message', (msg) => {
  if (msg.type === 'data') {
    content += Buffer.from(msg.chunk, 'base64').toString();
  } else if (msg.type === 'end') {
    console.log('接收完成，大小:', content.length);
  }
});

进程集群中的IPC

使用cluster模块时，主进程和工作进程之间也通过IPC通信：

const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
  // 主进程
  const worker = cluster.fork();
  
  worker.on('message', (msg) => {
    console.log('主进程收到:', msg);
  });
  
  setInterval(() => {
    worker.send({ time: Date.now() });
  }, 1000);
} else {
  // 工作进程
  process.on('message', (msg) => {
    console.log('工作进程收到:', msg);
    process.send({ pong: true });
  });
}

IPC性能优化

1. 批量发送消息：减少消息数量，合并多次操作
2. 共享内存：对于频繁读写的数据，可以使用SharedArrayBuffer
3. 二进制数据传输：使用Buffer代替字符串
4. 连接复用：保持长连接而不是频繁创建销毁

// 使用Buffer传输二进制数据
const child = fork('child.js');
const image = fs.readFileSync('image.png');

child.send({
  type: 'image',
  data: image.buffer // 传输ArrayBuffer
}, [image.buffer]); // 转移所有权

错误处理与调试

IPC通信中需要特别注意错误处理：

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

// 通信错误处理
child.on('error', (err) => {
  console.error('IPC错误:', err);
});

// 子进程退出处理
child.on('exit', (code, signal) => {
  if (code !== 0) {
    console.error('子进程异常退出:', code, signal);
  }
});

// 消息序列化错误处理
try {
  child.send({ circular: {} });
  // 故意创建循环引用
  child.send.circular = child.send;
} catch (err) {
  console.error('消息序列化失败:', err);
}

安全注意事项

1. 验证消息来源，防止伪造消息
2. 对消息内容进行校验
3. 限制消息大小，防止DoS攻击
4. 敏感数据加密传输

// 简单的消息验证
const SECRET = 'your-secret-key';

// 父进程
child.send({
  data: { /* ... */ },
  signature: createSignature(data, SECRET)
});

// 子进程
process.on('message', (msg) => {
  if (verifySignature(msg.data, msg.signature, SECRET)) {
    // 处理消息
  } else {
    console.error('消息验证失败');
  }
});

实际应用场景

微服务架构

在微服务中，可以使用IPC进行本地服务间通信：

// user-service.js
process.on('message', async (msg) => {
  if (msg.service === 'user' && msg.action) {
    try {
      const result = await handleUserAction(msg.action, msg.params);
      process.send({
        id: msg.id,
        success: true,
        result
      });
    } catch (err) {
      process.send({
        id: msg.id,
        success: false,
        error: err.message
      });
    }
  }
});

任务队列处理

// task-manager.js
const { fork } = require('child_process');
const workers = [];

// 创建工作进程池
for (let i = 0; i < os.cpus().length; i++) {
  const worker = fork('task-worker.js');
  workers.push(worker);
}

// 轮询分配任务
let current = 0;
function dispatch(task) {
  workers[current].send(task);
  current = (current + 1) % workers.length;
}

跨平台注意事项

不同操作系统下IPC实现有差异：

1. Windows使用命名管道
2. Unix-like系统使用Unix域套接字
3. 消息大小限制可能不同
4. 错误处理方式可能有差异

// 检测平台特定行为
if (process.platform === 'win32') {
  // Windows特有处理
} else {
  // Unix-like系统处理
}

调试工具与技巧

1. 使用NODE_DEBUG=child_process环境变量查看详细日志
2. 通过process._channel访问底层IPC通道
3. 使用Wireshark等工具分析底层通信
4. 添加消息日志记录

// 记录所有IPC消息
const originalSend = process.send;
process.send = function(...args) {
  console.log('发送消息:', ...args);
  return originalSend.apply(this, args);
};

process.on('message', (msg) => {
  console.log('接收消息:', msg);
  // 原始处理逻辑...
});