Worker Threads

🧵 Worker Threads: Your Node.js Super Team!

The Big Picture: A Restaurant Kitchen 🍳

Imagine you’re running a busy restaurant. You (the main thread) take orders, greet customers, and keep everything running smoothly. But what if a customer orders a huge wedding cake that takes 2 hours to bake? You can’t just stop serving everyone else!

Solution? Hire kitchen helpers (Worker Threads) who work in the back, making the cake while you keep serving customers. That’s exactly what Worker Threads do in Node.js!

🌟 What Are Worker Threads?

Worker Threads are like extra brains for your Node.js app. The main brain (main thread) handles quick tasks, while worker brains handle heavy work in the background.

Think of it like this:

• Main Thread = 👨‍💼 Restaurant Manager (greets guests, takes orders)
• Worker Threads = 👨‍🍳 Kitchen Chefs (cook the food in the background)

// The magic starts here!
const { Worker } = require('worker_threads');

Why do we need them?

• Node.js normally uses ONE brain (single-threaded)
• Heavy math or data crunching blocks everything
• Worker Threads give us MORE brains working together!

📦 The worker_threads Module Overview

The worker_threads module is your toolbox for creating helpers. Here’s what’s inside:

graph TD
    A["worker_threads Module"] --> B["Worker Class"]
    A --> C["parentPort"]
    A --> D["workerData"]
    A --> E["MessageChannel"]
    A --> F["MessagePort"]
    A --> G["isMainThread"]
    A --> H["threadId"]

🏗️ Creating Worker Threads

Method 1: Separate File (Clean & Organized)

main.js - The Boss

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

// Hire a new helper!
const worker = new Worker('./helper.js');

console.log('Boss: Helper hired!');

helper.js - The Helper

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

console.log('Helper: Ready to work!');
parentPort.postMessage('Hello boss!');

Method 2: Inline Code (Quick & Easy)

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

const worker = new Worker(`
  const { parentPort } = require('worker_threads');
  parentPort.postMessage('I was born inline!');
`, { eval: true });

worker.on('message', (msg) => {
  console.log('Worker says:', msg);
});

👔 The Worker Class

The Worker class is how you create and control your helpers.

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

// Create with options
const worker = new Worker('./task.js', {
  workerData: { task: 'calculate' },
  resourceLimits: {
    maxOldGenerationSizeMb: 128
  }
});

Key Worker Options

📞 parentPort: The Worker’s Phone

parentPort is how workers talk to their boss (main thread). Think of it as a walkie-talkie!

// worker.js
const { parentPort } = require('worker_threads');

// Listen for messages from boss
parentPort.on('message', (task) => {
  console.log('Got task:', task);

  // Do some work...
  const result = task * 2;

  // Send result back!
  parentPort.postMessage(result);
});

In the main file:

const { Worker } = require('worker_threads');
const worker = new Worker('./worker.js');

worker.postMessage(21);  // Send task

worker.on('message', (result) => {
  console.log('Answer:', result);  // 42!
});

📦 workerData: Birthday Presents!

workerData is data you give to a worker when it’s created. Like a gift bag at birth!

// main.js
const { Worker } = require('worker_threads');

const worker = new Worker('./calculate.js', {
  workerData: {
    numbers: [1, 2, 3, 4, 5],
    operation: 'sum'
  }
});

// calculate.js
const { workerData, parentPort } = require('worker_threads');

// workerData is available immediately!
console.log('Got numbers:', workerData.numbers);
console.log('Operation:', workerData.operation);

const sum = workerData.numbers.reduce((a, b) => a + b);
parentPort.postMessage(sum);  // 15

Key Point: workerData is copied, not shared. Changes in the worker don’t affect the original!

🔌 MessageChannel & MessagePort

Sometimes workers need to talk directly to each other, not through the boss. That’s where MessageChannel comes in!

graph LR
    A["Worker 1"] <-->|MessageChannel| B["Worker 2"]
    C["Main Thread"] -.->|Creates Channel| A
    C -.->|Creates Channel| B

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

// Create a private phone line
const { port1, port2 } = new MessageChannel();

const worker1 = new Worker('./talker.js');
const worker2 = new Worker('./listener.js');

// Give each worker one end of the line
worker1.postMessage({ port: port1 }, [port1]);
worker2.postMessage({ port: port2 }, [port2]);

Transferable Objects: Notice [port1]? That TRANSFERS ownership. The main thread can’t use it anymore!

🎯 Worker Thread Events

Workers emit events to tell you what’s happening:

const { Worker } = require('worker_threads');
const worker = new Worker('./task.js');

// Got a message!
worker.on('message', (data) => {
  console.log('📨 Message:', data);
});

// Oops, something broke!
worker.on('error', (err) => {
  console.log('❌ Error:', err.message);
});

// Worker finished and quit
worker.on('exit', (code) => {
  console.log('👋 Exit code:', code);
});

// Worker is fully up and running
worker.on('online', () => {
  console.log('✅ Worker is online!');
});

Event Timeline

graph TD
    A["Worker Created"] --> B["online event"]
    B --> C["message events"]
    C --> D{Normal Exit?}
    D -->|Yes| E["exit code 0"]
    D -->|No| F["error event"]
    F --> G["exit code 1"]

⚔️ Workers vs Cluster: When to Use What?

This is the BIG question! Let’s break it down:

Worker Threads 🧵

Best for:

• Heavy calculations (math, crypto)
• Image/video processing
• Parsing large files
• CPU-intensive tasks

// Perfect for Worker Threads:
// Calculate prime numbers
const worker = new Worker('./primes.js', {
  workerData: { max: 1000000 }
});

Cluster 🏢

Best for:

• Handling many web requests
• Running multiple server copies
• Using all CPU cores for I/O
• Scaling HTTP servers

// Perfect for Cluster:
const cluster = require('cluster');
if (cluster.isPrimary) {
  // Fork workers for each CPU
  for (let i = 0; i < 4; i++) {
    cluster.fork();
  }
}

The Comparison

Simple Rule 🎯

CPU heavy? → Worker Threads Many requests? → Cluster Both? → Use both together!

🚀 Real-World Example: Image Processor

Let’s see everything working together!

// main.js - The Boss
const { Worker } = require('worker_threads');

function processImage(imagePath) {
  return new Promise((resolve, reject) => {
    const worker = new Worker('./image-worker.js', {
      workerData: { imagePath }
    });

    worker.on('message', resolve);
    worker.on('error', reject);
  });
}

// Process 3 images at once!
Promise.all([
  processImage('cat.jpg'),
  processImage('dog.jpg'),
  processImage('bird.jpg')
]).then(results => {
  console.log('All done!', results);
});

// image-worker.js - The Helper
const { workerData, parentPort } = require('worker_threads');

// Heavy image work here...
const result = `Processed: ${workerData.imagePath}`;

parentPort.postMessage(result);

✨ Key Takeaways

1. Worker Threads = Extra Brains for heavy work
2. parentPort = Worker’s phone to talk to boss
3. workerData = Gift data at worker creation
4. MessageChannel = Direct worker-to-worker line
5. Events = Know when workers are online, done, or crashed
6. Workers vs Cluster = CPU work vs request scaling

🎉 You Did It!

You now understand how to:

• Create workers that work in the background
• Send messages back and forth
• Pass data at creation time
• Set up direct communication channels
• Handle all worker events
• Choose between Workers and Cluster

Your Node.js apps are about to get WAY faster! 🚀

Remember: When your main thread feels slow, just hire some helpers! 👨‍🍳👩‍🍳👨‍🍳