The concept of processes and threads

Basic Concepts of Processes and Threads

A process is the fundamental unit of resource allocation in an operating system, with each process having independent memory space, file descriptors, and other system resources. Threads are execution units within a process, sharing the process's resources but possessing independent execution stacks and program counters. The operating system ensures program stability through process isolation, while threads are used to improve program execution efficiency.

Although Node.js follows a single-threaded model, it achieves high concurrency through an event loop and asynchronous I/O. Under the hood, it still relies on a thread pool to handle certain tasks, such as file I/O and DNS queries. This design avoids the complexity of multithreaded programming while fully leveraging the advantages of multi-core CPUs.

// View Node.js process information
console.log(`Process PID: ${process.pid}`);
console.log(`Memory usage: ${JSON.stringify(process.memoryUsage())}`);

Process Model in Node.js

The Node.js main process runs the V8 engine and event loop, creating a single process when the application starts. This main process is responsible for executing JavaScript code, scheduling events, and handling request responses. For CPU-intensive tasks, Node.js provides the child_process module to create child processes. Typical scenarios include:

• Image/video processing
• Big data computation
• Machine learning inference

const { fork } = require('child_process');
const computeProcess = fork('./heavy-computation.js');

computeProcess.send({ data: largeDataSet });
computeProcess.on('message', result => {
  console.log('Computation result:', result);
});

Event Loop and Thread Pool

Node.js implements the event loop mechanism through the libuv library. This core architecture consists of six main phases:

1. Timers phase (handles setTimeout/setInterval)
2. Pending callbacks phase (executes system operation callbacks)
3. Idle/Prepare phase (internal use)
4. Poll phase (retrieves new I/O events)
5. Check phase (executes setImmediate callbacks)
6. Close callbacks phase (handles close events)

The underlying thread pool defaults to 4 threads (adjustable via the UV_THREADPOOL_SIZE environment variable) and is used for:

• File system operations
• DNS resolution
• Certain cryptographic operations
• All asynchronous Zlib operations

const fs = require('fs');
const crypto = require('crypto');

// These operations use the thread pool
fs.readFile('/large-file', (err, data) => {
  crypto.pbkdf2('password', 'salt', 100000, 64, 'sha512', (err, key) => {
    console.log(key.toString('hex'));
  });
});

Cluster Mode and Inter-Process Communication

For multi-core systems, Node.js provides the cluster module to implement a multi-process architecture. The main process (master) can fork multiple worker processes, which share server ports but run independent V8 instances. Inter-process communication primarily occurs through:

1. IPC channels (automatically established with child_process.fork())
2. Shared file descriptors
3. Third-party message queues (e.g., Redis)

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  for (let i = 0; i < numCPUs; i++) {
    const worker = cluster.fork();
    worker.send('Message from master');
  }
} else {
  process.on('message', (msg) => {
    console.log(`Worker ${process.pid} received: ${msg}`);
  });
  
  http.createServer((req, res) => {
    res.end(`Handled by Worker ${process.pid}`);
  }).listen(8000);
}

Detailed Explanation of the Worker Threads Module

Node.js 10+ introduced the worker_threads module, enabling true multithreading. Unlike child processes, worker threads:

• Share process memory (via SharedArrayBuffer)
• Have lower startup overhead
• Are suitable for CPU-intensive JavaScript operations

Typical use cases include:

• Complex mathematical computations
• Large-scale JSON processing
• Image pixel manipulation

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

if (isMainThread) {
  const worker = new Worker(__filename);
  worker.on('message', msg => console.log('Main thread received:', msg));
  worker.postMessage('ping');
} else {
  parentPort.on('message', msg => {
    console.log('Worker thread received:', msg);
    parentPort.postMessage('pong');
  });
}

Memory Management and Resource Sharing

In a multi-process architecture, memory is not shared, and each process has its own heap memory. Worker threads, however, can share data through:

1. SharedArrayBuffer: Truly shared memory
2. MessagePort: Communication channel between threads
3. Atomics API: Atomic operations on shared memory

const { Worker } = require('worker_threads');
const sharedBuffer = new SharedArrayBuffer(4);
const array = new Int32Array(sharedBuffer);

const worker = new Worker(`
  const { parentPort, workerData } = require('worker_threads');
  const array = new Int32Array(workerData);
  Atomics.add(array, 0, 1);
  parentPort.postMessage('done');
`, { workerData: sharedBuffer });

worker.on('message', () => {
  console.log('Shared array value:', array[0]);  // Outputs 1
});

Error Handling and Process Monitoring

Error handling is critical in multi-process/thread environments:

1. Child process crashes do not affect the main process
2. Uncaught thread exceptions cause the thread to exit
3. Process daemon mechanisms should be implemented

const { spawn } = require('child_process');
const child = spawn('node', ['worker.js']);

child.on('exit', (code, signal) => {
  if (code !== 0) {
    console.error(`Child process exited abnormally with code ${code}`);
    // Implement auto-restart logic
    spawn('node', ['worker.js']); 
  }
});

process.on('uncaughtException', (err) => {
  console.error('Uncaught exception in main process:', err);
  // Graceful shutdown
  server.close(() => process.exit(1));
});

Performance Optimization Practices

Choose the appropriate multitasking approach based on the application type:

• I/O-intensive: Single-threaded + asynchronous I/O
• CPU-intensive: Worker threads or process pools
• Hybrid: Combination of approaches

// Thread pool implementation example
const { Worker, isMainThread, parentPort, workerData } = require('worker_threads');
const os = require('os');

class ThreadPool {
  constructor(script, size = os.cpus().length) {
    this.workers = Array(size).fill().map(() => new Worker(script));
    this.taskQueue = [];
    this.workers.forEach(worker => {
      worker.on('message', () => this.assignNextTask(worker));
    });
  }

  assignNextTask(worker) {
    if (this.taskQueue.length) {
      const { task, resolve } = this.taskQueue.shift();
      worker.once('message', resolve);
      worker.postMessage(task);
    }
  }

  execute(task) {
    return new Promise(resolve => {
      this.taskQueue.push({ task, resolve });
      this.assignNextTask(this.workers.find(w => !w.isBusy));
    });
  }
}

Debugging and Performance Analysis

Node.js provides various tools for multitasking debugging:

1. --inspect-brk parameter for debugging the main process
2. Automatic increment of debug ports for worker_threads
3. Using 0x to generate flame graphs for performance bottleneck analysis

// Measure thread performance
const { performance, PerformanceObserver } = require('perf_hooks');
const obs = new PerformanceObserver((items) => {
  console.log(items.getEntries()[0].duration);
  performance.clearMarks();
});
obs.observe({ entryTypes: ['measure'] });

performance.mark('A');
// Execute multithreaded task
performance.mark('B');
performance.measure('A to B', 'A', 'B');