Node.js中两个子进程间直接通信的高效实现方案咨询

Great question! You’re absolutely right that forwarding messages through the main process adds unnecessary overhead and complexity. There are a couple of straightforward ways to enable direct communication between your input and upload (Puppeteer) child processes, depending on whether you need cross-platform support or are targeting Unix-like systems specifically.

Approach 1: Cross-Platform Named Pipes #

Named pipes work seamlessly on both Windows and Unix-like systems, making them a solid choice for cross-platform applications. Here’s how to implement this:

Step 1: Set up the Upload (Puppeteer) Process to Listen on a Named Pipe #

In upload.js, we’ll initialize Puppeteer in parallel with setting up a named pipe server to wait for the input process’s folder path:

const { createServer } = require('net');
const path = require('path');
const puppeteer = require('puppeteer');

// Define a platform-appropriate pipe path
const pipePath = process.platform === 'win32' 
  ? '\\\\.\\pipe\\puppeteer-input-pipe' 
  : path.join('/tmp', 'puppeteer-input-pipe');

(async () => {
  // Start Puppeteer workflow in parallel
  console.log('Initializing Puppeteer...');
  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.goto('your-target-site.com');
  await page.type('#username', 'your-username');
  await page.type('#password', 'your-password');
  await page.click('#login-button');
  await page.waitForNavigation();
  console.log('Puppeteer logged in and ready!');

  // Set up pipe server to listen for folder path
  const server = createServer((socket) => {
    console.log('Input process connected via pipe');
    socket.on('data', async (data) => {
      const message = JSON.parse(data.toString());
      if (message.type === 'upload') {
        const folderPath = message.data;
        console.log(`Received folder path: ${folderPath}`);
        
        // Execute your upload logic here with Puppeteer
        // Example: await uploadFilesFromFolder(page, folderPath);
        
        // Cleanup resources
        socket.end();
        server.close();
        await browser.close();
      }
    });
  });

  server.listen(pipePath, () => {
    console.log(`Listening for input on pipe: ${pipePath}`);
  });
})();

Step 2: Modify the Input Process to Send Data via the Named Pipe #

In your input process (app.js), once you capture the user’s folder path, connect directly to the named pipe and send the data:

const { createConnection } = require('net');
const path = require('path');

// Same pipe path as defined in upload.js
const pipePath = process.platform === 'win32' 
  ? '\\\\.\\pipe\\puppeteer-input-pipe' 
  : path.join('/tmp', 'puppeteer-input-pipe');

// Simulate user input (replace with your actual input flow)
async function getUserFolderPath() {
  return new Promise((resolve) => {
    console.log('Please enter the folder path to upload:');
    process.stdin.once('data', (input) => {
      resolve(input.toString().trim());
    });
  });
}

(async () => {
  const folderPath = await getUserFolderPath();
  console.log(`User provided folder: ${folderPath}`);

  // Connect to the pipe and send the data
  const socket = createConnection(pipePath, () => {
    console.log('Connected to upload process');
    socket.write(JSON.stringify({
      type: 'upload',
      data: folderPath
    }));
    socket.end();
  });

  socket.on('error', (err) => {
    console.error('Failed to connect to upload pipe:', err);
  });
})();

Step 3: Simplify the Main Process #

Your main process (index.js) now only needs to fork both processes—no more message forwarding logic:

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

// Fork both processes (they handle direct communication)
const input = fork('./app.js');
const upload = fork('./upload.js');

// Optional: Log debug messages from children
input.on('message', (msg) => console.log('Input process:', msg));
upload.on('message', (msg) => console.log('Upload process:', msg));

Approach 2: Unix Domain Sockets (Unix-like Systems Only) #

If you’re only targeting Linux/macOS, Unix domain sockets are a lightweight alternative to named pipes. The implementation is nearly identical—just replace the pipe path with a socket file path, and add cleanup to delete the socket file before starting the server to avoid "address already in use" errors.

Why This Works Better #

• Lower Overhead: No intermediate hop through the main process reduces latency and simplifies your codebase.
• Clean Separation: Each process focuses on its core job (input handling vs. Puppeteer automation) without relying on the main process as a message relay.
• Full Parallelism: Both processes initialize independently, so you fully utilize the time the user spends entering the folder path to get Puppeteer up and running.

A quick edge case note: If the input process is ready before Puppeteer finishes initializing, you can add retry logic in the input process to keep trying to connect to the pipe until it’s available.

内容的提问来源于stack exchange，提问作者TheOddOne