Receiving results from workers in Node.js - Step-by-Step Execution

Concept Flow - Receiving results from workers

Main thread starts worker

↓

Worker runs task

↓

Worker sends result message

↓

Main thread receives message

↓

Main thread processes result

↓

End

The main thread starts a worker, the worker runs a task and sends back a message, then the main thread receives and processes the result.

Execution Sample

Node.js

import { Worker } from 'worker_threads';

const worker = new Worker('./worker.js');
worker.on('message', (result) => {
  console.log('Result:', result);
});

Main thread creates a worker and listens for messages containing results.

Execution Table

Step	Action	Worker State	Main Thread State	Message/Event
1	Main thread creates worker	Idle	Worker created	No message
2	Worker starts task	Running task	Waiting for message	No message
3	Worker finishes task	Task complete	Waiting for message	No message
4	Worker sends result message	Sent message	Message event queued	Message with result sent
5	Main thread receives message	Idle	Message received	Message event handled
6	Main thread processes result	Idle	Result processed	Console logs result
7	End	Idle	Idle	No message

💡 Worker sent result message and main thread processed it, communication complete.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 5	Final
workerState	Idle	Running task	Sent message	Idle	Idle
mainThreadState	Worker created	Waiting for message	Message event queued	Message received	Result processed
message	None	None	Result message sent	Result message received	Processed

Key Moments - 3 Insights

Why does the main thread wait before receiving the worker's message?

Because the worker must finish its task and send a message first (see steps 2 to 4 in execution_table). The main thread listens but does not get the message until the worker sends it.

What happens if the worker sends multiple messages?

The main thread's 'message' event handler will be called for each message received, processing them one by one as they arrive.

Is the workerState 'Idle' immediately after sending the message?

No, the worker is 'Sent message' at step 4, then becomes 'Idle' after the main thread receives the message (step 5).

Visual Quiz - 3 Questions

Look at the execution_table, what is the workerState at step 3?

A Task complete

B Running task

C Idle

D Sent message

💡 Hint

Check the 'Worker State' column at step 3 in the execution_table.

At which step does the main thread receive the worker's message?

A Step 4

B Step 5

C Step 6

D Step 3

💡 Hint

Look for 'Message received' in the 'Main Thread State' column.

If the worker never sends a message, what will the main thread state be after step 4?

A Message event queued

B Result processed

C Waiting for message

D Worker created

💡 Hint

Refer to the 'Main Thread State' column and consider what happens if no message arrives.

Concept Snapshot

Receiving results from workers in Node.js:
- Main thread creates a Worker instance.
- Worker runs code and sends messages with parentPort.postMessage().
- Main thread listens with worker.on('message', callback).
- Messages carry results from worker to main thread.
- Main thread processes results inside the message event handler.

Full Transcript

In Node.js, the main thread creates a worker thread to run code separately. The worker performs a task and sends results back using messages. The main thread listens for these messages with an event handler. When the worker sends a message, the main thread receives it and processes the result. This allows parallel work and communication between threads.

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