Receiving results from workers in Node.js - Mini Project: Build & Apply

Receiving Results from Workers in Node.js

📖 Scenario: You are building a Node.js application that uses worker threads to perform tasks in the background. You want to receive results from these workers and handle them in the main thread.

🎯 Goal: Create a simple Node.js program that starts a worker thread, sends a task to it, and receives the result back in the main thread.

📋 What You'll Learn

Create a worker thread using the worker_threads module

Send a message from the main thread to the worker

Receive a message from the worker in the main thread

Log the received result in the main thread

💡 Why This Matters

🌍 Real World

Worker threads help Node.js applications perform CPU-heavy tasks without blocking the main thread, improving responsiveness.

💼 Career

Understanding worker threads is important for backend developers building scalable and efficient Node.js applications that handle concurrent tasks.

1

Set up the worker thread file

Create a file named worker.js that imports parentPort from worker_threads and listens for messages using parentPort.on('message', ...).

Node.js

// Your code here to import parentPort and listen for messages

Hint

Use require('worker_threads') to get parentPort. Then use parentPort.on('message', callback) to listen for messages.

2

Add a task handler in the worker

Inside the parentPort.on('message', ...) callback in worker.js, create a variable result that doubles the received value. Then send the result back to the main thread using parentPort.postMessage(result).

Node.js

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

parentPort.on('message', (value) => {
    // Calculate result and send it back
});

Hint

Multiply value by 2 and send it back with parentPort.postMessage().

3

Create the main thread file and start the worker

Create a file named main.js. Import Worker from worker_threads. Create a new Worker instance with the filename './worker.js'. Send the number 10 to the worker using worker.postMessage(10).

Node.js

// Your code here to import Worker and create a worker instance
// Then send 10 to the worker

Hint

Use new Worker('./worker.js') to start the worker and worker.postMessage(10) to send data.

4

Receive and log the result from the worker

In main.js, add a listener for worker.on('message', ...) that receives the result from the worker and logs it using console.log with the text "Result from worker:" followed by the result.

Node.js

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

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

// Add listener to receive message from worker

Hint

Use worker.on('message', callback) to get the result and console.log to show it.

Practice

1. In Node.js, how do you receive results from a worker thread?

easy

A. By using console.log inside the worker

B. By calling worker.getResult() method

C. By listening to the message event on the worker

D. By reading from a shared file

Solution

1. Step 1: Understand worker communication

   Workers send results back to the main thread using messages.

2. Step 2: Use the correct event listener

   The main thread listens to the message event on the worker to receive data.

3. Final Answer:

   By listening to the message event on the worker -> Option C

4. Quick Check:

   message event = D [OK]

Hint: Remember: workers send data via 'message' events [OK]

Common Mistakes:

• Trying to call a non-existent method like getResult()
• Expecting console.log output to be received
• Reading results from files instead of messages

2. Which of the following is the correct syntax to listen for messages from a worker in Node.js?

easy

A. worker.on('message', (result) => { console.log(result); });

B. worker.listen('message', (result) => { console.log(result); });

C. worker.addEventListener('message', (result) => { console.log(result); });

D. worker.receive('message', (result) => { console.log(result); });

Solution

1. Step 1: Recall Node.js worker event syntax

   Node.js workers use the on method to listen for events.

2. Step 2: Identify the correct event and method

   The event to receive data is message, and the syntax is worker.on('message', callback).

3. Final Answer:

   worker.on('message', (result) => { console.log(result); }); -> Option A

4. Quick Check:

   worker.on('message') = A [OK]

Hint: Use worker.on('message', callback) to get results [OK]

Common Mistakes:

• Using non-existent methods like listen or receive
• Confusing browser event syntax with Node.js
• Using addEventListener which is not in Node.js workers

3. What will be logged to the console when this Node.js worker code runs?

const { Worker } = require('worker_threads');
const worker = new Worker(`
  const { parentPort } = require('worker_threads');
  parentPort.postMessage('Hello from worker');
`, { eval: true });
worker.on('message', (msg) => console.log(msg));

medium

A. undefined

B. No output

C. Error: parentPort is not defined

D. Hello from worker

Solution

1. Step 1: Understand worker code execution

   The worker sends a message 'Hello from worker' using parentPort.postMessage.

2. Step 2: Check main thread message listener

   The main thread listens to the message event and logs the received message.

3. Final Answer:

   Hello from worker -> Option D

4. Quick Check:

   postMessage sends 'Hello from worker' = B [OK]

Hint: postMessage sends data, main thread logs it on 'message' event [OK]

Common Mistakes:

• Expecting no output because of missing event listener
• Confusing parentPort usage causing errors
• Assuming worker code runs in main thread

4. Identify the error in this Node.js worker communication code:

const { Worker } = require('worker_threads');
const worker = new Worker('./worker.js');
worker.on('message', (data) => {
  console.log('Received:', data);
});
parentPort.postMessage('start');

medium

A. Cannot call postMessage on the worker instance

B. postMessage should be called on parentPort inside worker, not on worker instance

C. Missing error event listener on worker

D. The worker file path is incorrect

Solution

1. Step 1: Understand where postMessage is called

   In Node.js, postMessage is called on parentPort inside the worker, not on the worker instance in main thread.

2. Step 2: Identify correct communication method

   The main thread uses worker.postMessage() to send messages to the worker, but inside the worker, parentPort.postMessage() sends messages back.

3. Final Answer:

   postMessage should be called on parentPort inside worker, not on worker instance -> Option B

4. Quick Check:

   postMessage usage inside worker = C [OK]

Hint: postMessage on worker sends to worker; inside worker use parentPort.postMessage [OK]

Common Mistakes:

• Confusing where to call postMessage
• Ignoring error event listeners
• Assuming worker file path is wrong without evidence

5. You want to receive multiple results from a worker that sends messages repeatedly. Which approach correctly handles this in Node.js?

const { Worker } = require('worker_threads');
const worker = new Worker('./worker.js');
// What should you do here to receive all messages?

hard

A. Use worker.on('message', (msg) => { console.log(msg); }); to listen continuously

B. Call worker.once('message', (msg) => { console.log(msg); }); to listen once

C. Use a loop to call worker.postMessage repeatedly

D. Use setTimeout to poll worker for messages

Solution

1. Step 1: Understand event listeners for multiple messages

   Using worker.on('message') listens continuously for all messages sent by the worker.

2. Step 2: Compare with other options

   once listens only once, loops or polling are unnecessary and inefficient for receiving messages.

3. Final Answer:

   Use worker.on('message', (msg) => { console.log(msg); }); to listen continuously -> Option A

4. Quick Check:

   Continuous message listening = A [OK]

Hint: Use worker.on('message') for all messages, not once or polling [OK]

Common Mistakes:

• Using once instead of on for multiple messages
• Trying to poll worker instead of event listening
• Confusing sending messages with receiving them