Why worker threads matter in Node.js - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use worker threads in Node.js?

Which of the following best explains why worker threads are important in Node.js?

A They automatically optimize memory usage for all Node.js applications.

B They replace the need for asynchronous callbacks in Node.js.

C They allow Node.js to run multiple JavaScript operations in parallel without blocking the main thread.

D They enable Node.js to run on multiple machines at the same time.

💡 Hint

Think about how Node.js handles tasks and what happens when a task takes a long time.

Worker threads let Node.js run JavaScript code in parallel threads. This helps avoid blocking the main thread, which keeps the app responsive.

❓ component_behavior

intermediate

Output of worker thread example

What will be the output of this Node.js code using worker threads?

Node.js

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

if (isMainThread) {
  const worker = new Worker(__filename);
  worker.on('message', message => console.log('From worker:', message));
  console.log('Main thread running');
} else {
  parentPort.postMessage('Hello from worker');
}

A Main thread running

B Main thread running\nFrom worker: Hello from worker

C From worker: Hello from worker\nMain thread running

D From worker: Hello from worker

💡 Hint

Consider the order of console.log calls in main and worker threads.

The main thread logs first, then the worker sends a message back which is logged next.

🔧 Debug

advanced

Identify the error in worker thread usage

What error will this Node.js code produce?

Node.js

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

const worker = new Worker('console.log("Hello")');

A SyntaxError: Unexpected token 'console.log("Hello")'

B ReferenceError: Worker is not defined

C No error, prints 'Hello'

D TypeError: Worker constructor expects a file path or URL

💡 Hint

Check what the Worker constructor expects as input.

The Worker constructor requires a file path or URL, not a string of code.

❓ state_output

advanced

State sharing between main and worker threads

Given this code, what will be the final value of 'counter' in the main thread?

Node.js

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

let counter = 0;

if (isMainThread) {
  const worker = new Worker(__filename, { workerData: counter });
  worker.on('message', value => {
    counter = value;
    console.log('Counter in main:', counter);
  });
} else {
  let localCounter = workerData;
  localCounter += 5;
  parentPort.postMessage(localCounter);
}

A Counter in main: 5

B Counter in main: 1

C Counter in main: undefined

D Counter in main: 0

💡 Hint

Remember that workerData is a copy, not shared memory.

The worker receives a copy of counter (0), adds 5, and sends back 5. The main thread updates its counter to 5.

📝 Syntax

expert

Correct syntax to create a worker thread with inline code

Which option correctly creates a worker thread that runs inline JavaScript code in Node.js?

A new Worker(new URL('data:text/javascript,console.log("Hello")'), { type: 'module' });

B new Worker('console.log("Hello")');

C new Worker(() => console.log('Hello'));

D new Worker({ code: 'console.log("Hello")' });

💡 Hint

Worker constructor accepts a file path, URL, or data URL with type module.

Option A uses a data URL with type 'module' which is the correct way to run inline code in a worker thread.

Practice

1. Why do worker threads matter in Node.js?

easy

A. They allow running heavy tasks without freezing the main app.

B. They replace the need for asynchronous programming.

C. They make the app use less memory.

D. They automatically fix bugs in the code.

Solution

1. Step 1: Understand the main thread limitation

   Node.js runs JavaScript on a single main thread, so heavy tasks can block it and freeze the app.

2. Step 2: Role of worker threads

   Worker threads run heavy tasks in parallel, keeping the main thread free and the app responsive.

3. Final Answer:

   They allow running heavy tasks without freezing the main app. -> Option A

4. Quick Check:

   Worker threads keep app responsive = B [OK]

Hint: Worker threads run heavy tasks separately to avoid freezing [OK]

Common Mistakes:

• Thinking worker threads replace async programming
• Believing worker threads reduce memory automatically
• Assuming worker threads fix bugs

2. Which of the following is the correct way to create a worker thread in Node.js?

easy

A. const worker = createWorker('./worker.js');

B. const worker = Worker.create('./worker.js');

C. const worker = new Thread('./worker.js');

D. const worker = new Worker('./worker.js');

Solution

1. Step 1: Recall the Worker class usage

   Node.js uses the Worker class from 'worker_threads' module to create worker threads.

2. Step 2: Correct syntax

   The correct syntax is creating a new Worker instance with the file path as argument.

3. Final Answer:

   const worker = new Worker('./worker.js'); -> Option D

4. Quick Check:

   Use new Worker() to create worker thread = D [OK]

Hint: Use new Worker() with file path to create worker [OK]

Common Mistakes:

• Using Worker.create() which does not exist
• Using Thread instead of Worker
• Calling createWorker() which is not a Node.js method

3. What will the following code output?

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. SyntaxError due to missing import

B. From worker: Hello

C. From worker: Hello World

D. No output because message event is not handled

Solution

1. Step 1: Understand main vs worker thread

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

2. Step 2: Worker message handling

   The worker listens for messages, appends ' World' to the received message, and sends it back.

3. Final Answer:

   From worker: Hello World -> Option C

4. Quick Check:

   Worker appends ' World' and sends back = A [OK]

Hint: Worker adds ' World' to message and replies [OK]

Common Mistakes:

• Confusing main thread and worker thread roles
• Missing parentPort import causing errors
• Assuming no output without understanding message events

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 must be absolute

B. Missing import of parentPort in worker.js

C. Cannot call postMessage on worker instance

D. Event listener 'message' should be 'onmessage'

Solution

1. Step 1: Check main thread code

   Main thread creates worker and sends message correctly.

2. Step 2: Common worker.js mistake

   Inside worker.js, parentPort must be imported to receive and send messages.

3. Final Answer:

   Missing import of parentPort in worker.js -> Option B

4. Quick Check:

   Worker needs parentPort import to communicate = C [OK]

Hint: Worker.js must import parentPort to handle messages [OK]

Common Mistakes:

• Thinking postMessage is invalid on worker instance
• Believing file path must be absolute always
• Using 'onmessage' instead of 'message' event

5. You want to perform CPU-heavy calculations in a Node.js app without blocking the main thread. Which approach best uses worker threads to achieve this?

hard

A. Create a worker thread for each calculation and communicate results via messages.

B. Run all calculations in the main thread using async/await.

C. Use setTimeout to delay calculations in the main thread.

D. Spawn child processes instead of worker threads for parallelism.

Solution

1. Step 1: Understand CPU-heavy task impact

   CPU-heavy tasks block the main thread if run there, freezing the app.

2. Step 2: Worker threads for parallelism

   Creating worker threads for each calculation runs them in parallel without blocking the main thread, communicating results via messages.

3. Step 3: Evaluate other options

   Async/await does not prevent blocking for CPU tasks; setTimeout only delays but does not parallelize; child processes are heavier and more complex than worker threads.

4. Final Answer:

   Create a worker thread for each calculation and communicate results via messages. -> Option A

5. Quick Check:

   Use worker threads for parallel CPU tasks = A [OK]

Hint: Use worker threads to run heavy tasks in parallel [OK]

Common Mistakes:

• Thinking async/await avoids CPU blocking
• Using setTimeout to fix blocking issues
• Confusing child processes with worker threads