Multithreading in Node.js: Evolution from Processes to Worker Threads and Practical Implementation

Introduction

Node.js has long been known for its single-threaded event loop architecture, which excels at handling I/O-intensive tasks but can become a bottleneck for CPU-intensive operations. As application complexity increases, the demand for multithreading support has grown. This article systematically introduces the evolution of multithreading in Node.js, from early child processes to modern Worker Threads, and provides practical code examples.

Traditional Approach: Child Processes

Before the advent of Worker Threads, Node.js primarily achieved parallel processing through the child_process module. This module allows the creation of independent child processes, each with its own memory space and event loop. Here is a basic example:

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

const child = spawn('node', ['worker.js']);

child.stdout.on('data', (data) => {
  console.log(`Child process output: ${data}`);
});

child.on('close', (code) => {
  if (code !== 0) {
    console.error(`Child process exited with code: ${code}`);
    // Logic to terminate other related processes can be added here
  }
});

The main advantage of this method is good inter-process isolation, but it has significant drawbacks: high process creation overhead, inefficient inter-process communication (IPC), and the need for data serialization. For example, when passing a string containing HTML tags like <br>, proper encoding is required to avoid parsing errors.

Third-Party Libraries: node-webworker-threads

Before native multithreading support in Node.js, community-developed libraries such as node-webworker-threads emerged, implementing thread functionality based on the Web Worker API. This library allows creating multiple threads within a single Node.js process, sharing some memory but running independent JavaScript contexts. Example code:

const { Worker } = require('webworker-threads');

const worker = new Worker(function() {
  this.onmessage = function(event) {
    const data = event.data;
    // Process data, escaping special characters like < and >
    const result = data.replace(/</g, '[').replace(/>/g, ']');
    postMessage(result);
  };
});

worker.onmessage = function(event) {
  console.log('Received message from thread:', event.data);
};

worker.postMessage('Process string: <tag>');

Although such libraries offer a lighter-weight threading model, they rely on external dependencies and may have compatibility issues across different Node.js versions. For instance, when handling code containing <T>, explicit escaping is needed to avoid HTML parsing errors, such as using print("<T>").

Modern Solution: Worker Threads API

Starting from Node.js 10.5.0, experimental Worker Threads support was introduced, becoming stable in Node.js 12 LTS. This API allows creating multiple threads within a single Node.js process, each running an independent V8 instance but capable of sharing memory (via SharedArrayBuffer). Here is an example of creating and managing Worker Threads:

const { Worker, isMainThread, parentPort } = require('worker_threads');

if (isMainThread) {
  // Main thread code
  const worker = new Worker(__filename);
  
  worker.on('message', (msg) => {
    console.log('Main thread received:', msg);
  });
  
  worker.on('error', (err) => {
    console.error('Thread error:', err);
    worker.terminate(); // Terminate this thread
    // Logic to terminate other threads can be extended here
  });
  
  worker.postMessage({ task: 'process', data: 'Example data<br>' });
} else {
  // Worker thread code
  parentPort.on('message', (msg) => {
    if (msg.task === 'process') {
      const processed = msg.data.toUpperCase();
      parentPort.postMessage(`Processed result: ${processed}`);
    }
  });
}

Worker Threads offer significant advantages over child processes: lower creation overhead, efficient inter-thread communication (supporting transfer of ArrayBuffer and SharedArrayBuffer), and easier management. For example, when passing strings containing HTML entities like <, no additional escaping is required as data is transmitted in binary form.

Error Handling and Thread Termination Strategy

As per the question requirements, when any thread fails, all related threads must be terminated. This can be achieved by listening for error events in the main thread and coordinating other threads. Here is an example implementing this strategy:

const { Worker } = require('worker_threads');

class ThreadPool {
  constructor(script, count) {
    this.workers = [];
    for (let i = 0; i < count; i++) {
      const worker = new Worker(script);
      worker.on('error', (err) => this.handleError(worker, err));
      this.workers.push(worker);
    }
  }
  
  handleError(failedWorker, err) {
    console.error(`Thread failed: ${err.message}`);
    // Terminate all threads
    this.workers.forEach(w => {
      if (w !== failedWorker && w.threadId) {
        w.terminate();
      }
    });
    failedWorker.terminate();
  }
  
  distributeTask(task) {
    this.workers.forEach(worker => {
      worker.postMessage(task);
    });
  }
}

// Usage example
const pool = new ThreadPool('./worker.js', 4);
pool.distributeTask({ data: 'Execute task' });

This approach ensures system robustness, especially when handling input data that may contain unescaped characters like <div>, preventing error propagation. Note that when using <div> directly as a string in code, it should be escaped as <div> to avoid parsing issues.

Performance Comparison and Best Practices

In practical applications, choosing a multithreading technology requires balancing performance, complexity, and requirements. Child processes are suitable for fully isolated tasks, while Worker Threads are better for scenarios requiring shared memory or frequent communication. Performance tests show that Worker Threads can be over 30% faster than child processes for CPU-intensive tasks due to avoided process creation and IPC overhead.

Best practices include: using worker_threads for thread management, leveraging SharedArrayBuffer for efficient data sharing, and implementing strict error handling. For example, when processing user input, always escape special characters, such as converting <script> to <script>, to prevent security vulnerabilities.

Conclusion

Multithreading support in Node.js has evolved from an experimental feature to a stable API, providing developers with powerful parallel processing capabilities. Through Worker Threads, multiple methods can be run efficiently, and all threads can be quickly terminated upon error, meeting the demands of modern applications. Developers should master these technologies, choose appropriate solutions based on real-world scenarios, and pay attention to data escaping and error handling to ensure application stability and security. In the future, as Node.js evolves, multithreading programming may be further optimized, leading to more efficient concurrency models.