Creating worker threads in Node.js - Try It Yourself

Creating worker threads

📖 Scenario: You are building a Node.js application that needs to perform a heavy calculation without blocking the main program. To do this, you will use worker threads to run the calculation in the background.

🎯 Goal: Create a simple Node.js program that uses the worker_threads module to run a worker thread which calculates the sum of numbers from 1 to 1000000 and sends the result back to the main thread.

📋 What You'll Learn

Create a worker thread using the Worker class from the worker_threads module

Send a message from the main thread to the worker thread

Perform the sum calculation inside the worker thread

Send the result back from the worker thread to the main thread

💡 Why This Matters

🌍 Real World

Worker threads help Node.js applications perform CPU-heavy tasks without freezing the user interface or blocking other operations.

💼 Career

Understanding worker threads is important for backend developers to build scalable and responsive Node.js applications that handle intensive computations efficiently.

1

Import the worker_threads module and check if current thread is main

Write code to import Worker and isMainThread from the worker_threads module. Then create an if statement that checks if isMainThread is true.

Node.js

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

// Your code here

Hint

Use require('worker_threads') to import Worker and isMainThread. Then write if (isMainThread) { ... } else { ... } to separate main and worker code.

2

Create a new Worker instance in the main thread

Inside the if (isMainThread) block, create a new Worker instance that runs the current file using __filename. Assign it to a variable called worker.

Node.js

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

if (isMainThread) {
    const worker = new Worker(__filename);
    // Your code here
} else {
    // Worker thread code will go here
}

Hint

Create a Worker with new Worker(__filename) inside the main thread block.

3

Send a message from main thread and calculate sum in worker thread

In the main thread block, send a message { start: 1, end: 1000000 } to the worker using worker.postMessage(). In the else block (worker thread), listen for messages using parentPort.on('message', (data) => { ... }). Inside the listener, calculate the sum of numbers from data.start to data.end and send the result back using parentPort.postMessage(sum).

Node.js

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

if (isMainThread) {
    const worker = new Worker(__filename);
    worker.postMessage({ start: 1, end: 1000000 });
    // Your code here
} else {
    parentPort.on('message', (data) => {
        // Your code here
    });
}

Hint

Use worker.postMessage() in main thread to send data. In worker thread, use parentPort.on('message', ...) to receive data and calculate sum with a for loop. Then send result back with parentPort.postMessage().

4

Receive and handle the result in the main thread

In the main thread block, add a listener for worker.on('message', (result) => { ... }) to receive the sum result from the worker. Inside the listener, assign the received result to a variable called totalSum.

Node.js

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

if (isMainThread) {
    const worker = new Worker(__filename);
    worker.postMessage({ start: 1, end: 1000000 });
    worker.on('message', (result) => {
        // Your code here
    });
} else {
    parentPort.on('message', (data) => {
        let sum = 0;
        for (let i = data.start; i <= data.end; i++) {
            sum += i;
        }
        parentPort.postMessage(sum);
    });
}

Hint

Use worker.on('message', (result) => { ... }) in main thread to get the result and assign it to totalSum.

Practice

1. What is the main purpose of using worker_threads in Node.js?

easy

A. To handle HTTP requests faster

B. To simplify asynchronous callbacks

C. To manage database connections

D. To run code in parallel without blocking the main thread

Solution

1. Step 1: Understand worker threads role

   Worker threads allow running JavaScript code in parallel threads separate from the main thread.

2. Step 2: Compare with other options

   Options B, C, and D describe unrelated tasks; worker threads specifically help avoid blocking the main thread.

3. Final Answer:

   To run code in parallel without blocking the main thread -> Option D

4. Quick Check:

   Parallel code execution = A [OK]

Hint: Worker threads run code parallel to main thread [OK]

Common Mistakes:

• Confusing worker threads with async callbacks
• Thinking worker threads manage HTTP or DB tasks directly

2. Which of the following is the correct way to import the Worker class from the worker_threads module?

easy

A. const Worker = require('worker_threads');

B. import Worker from 'worker_threads';

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

D. const Worker = require('worker_threads').worker;

Solution

1. Step 1: Recall correct import syntax

   The Worker class is a named export, so we use destructuring: const { Worker } = require('worker_threads');

2. Step 2: Check other options

   const Worker = require('worker_threads'); assigns the entire module object, not the Worker class. import Worker from 'worker_threads'; uses ES module syntax which requires extra config. const Worker = require('worker_threads').worker; uses wrong property name.

3. Final Answer:

   const { Worker } = require('worker_threads'); -> Option C

4. Quick Check:

   Destructure Worker from module = D [OK]

Hint: Use destructuring to import Worker from worker_threads [OK]

Common Mistakes:

• Using wrong property name like 'worker' instead of 'Worker'
• Mixing CommonJS and ES module syntax incorrectly

3. What will be the output of the following code snippet?

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

if (isMainThread) {
  const worker = new Worker(__filename);
  worker.on('message', msg => console.log('From worker:', msg));
  worker.postMessage('Hello');
} else {
  parentPort.on('message', msg => {
    parentPort.postMessage(msg + ' World');
  });
}

medium

A. From worker: Hello World

B. From worker: Hello

C. SyntaxError

D. No output

Solution

1. Step 1: Understand main and worker thread roles

   Main thread creates a worker running the same file. It sends 'Hello' to worker.

2. Step 2: Trace message passing

   Worker receives 'Hello', appends ' World', and sends back 'Hello World'. Main thread logs this message.

3. Final Answer:

   From worker: Hello World -> Option A

4. Quick Check:

   Message sent + ' World' logged = B [OK]

Hint: Worker appends ' World' and sends back message [OK]

Common Mistakes:

• Expecting original message without modification
• Confusing main thread and worker thread roles
• Missing event listeners for messages

4. Identify the error in this worker thread code snippet:

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

const worker = new Worker('worker.js');
worker.on('message', msg => console.log(msg));
worker.postMessage('Start');

medium

A. Worker file path should be absolute or URL

B. Missing event listener for 'error' event

C. Cannot create Worker with a string filename

D. Cannot call postMessage on Worker instance

Solution

1. Step 1: Check Worker constructor argument

   The Worker constructor expects an absolute path or a URL, not just a relative string like 'worker.js'.

2. Step 2: Validate other options

   Cannot create Worker with a string filename is incorrect because Worker can be created with a filename if path is correct. Missing event listener for 'error' event is good practice but not an error. Cannot call postMessage on Worker instance is wrong; postMessage is valid on Worker.

3. Final Answer:

   Worker file path should be absolute or URL -> Option A

4. Quick Check:

   Worker needs absolute path or URL = C [OK]

Hint: Use absolute path or URL for Worker file [OK]

Common Mistakes:

• Using relative paths without resolving them
• Ignoring error event listeners
• Thinking postMessage is invalid on Worker

5. You want to create a worker thread that performs a CPU-heavy calculation and sends the result back. Which approach correctly creates the worker and handles the result asynchronously?

hard

A. Use new Worker() without arguments and call worker.send() to communicate

B. Use new Worker('./calc.js') with worker.on('message', callback) and send data via worker.postMessage()

C. Use require('worker_threads').run() to start the worker and get a promise

D. Create a child process with child_process.fork() and communicate with worker.postMessage()

Solution

1. Step 1: Identify correct Worker creation and communication

   Creating a worker with new Worker('./calc.js') and using worker.on('message') plus worker.postMessage() is the standard pattern.

2. Step 2: Eliminate incorrect options

   Use new Worker() without arguments and call worker.send() to communicate is invalid because Worker requires a filename or code. Use require('worker_threads').run() to start the worker and get a promise is incorrect; no run() method exists. Create a child process with child_process.fork() and communicate with worker.postMessage() uses child_process, not worker_threads, and postMessage is not valid on child processes.

3. Final Answer:

   Use new Worker('./calc.js') with worker.on('message', callback) and send data via worker.postMessage() -> Option B

4. Quick Check:

   Worker with filename + message events = A [OK]

Hint: Use new Worker(filename) and message events for communication [OK]

Common Mistakes:

• Trying to create Worker without filename
• Confusing child_process with worker_threads
• Using non-existent Worker methods