Worker thread vs child process in Node.js - Practice Questions

Challenge - 5 Problems

🧠 Conceptual

intermediate

Difference in memory sharing between worker threads and child processes

In Node.js, what is the main difference in how worker threads and child processes handle memory?

A Worker threads share the same memory space, while child processes have separate memory spaces.

B Child processes share the same memory space, while worker threads have separate memory spaces.

C Both worker threads and child processes share the same memory space.

D Neither worker threads nor child processes share memory; both use separate memory spaces.

💡 Hint

Think about how threads and processes work in general operating system terms.

Worker threads run in the same process and share memory, allowing faster communication. Child processes run independently with separate memory, requiring message passing.

❓ component_behavior

intermediate

Output behavior of worker thread vs child process

Consider this Node.js code snippet that creates a worker thread and a child process, both printing a message. What will be the order of outputs in the console?

Node.js

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

console.log('Main start');

const worker = new Worker(`
  const { parentPort } = require('worker_threads');
  parentPort.postMessage('Worker done');
`, { eval: true });

const child = fork('./child.js');

worker.on('message', msg => console.log(msg));
child.on('message', msg => console.log(msg));

console.log('Main end');

A

Main start
Main end
Child done
Worker done

B

Main start
Worker done
Main end
Child done

C

Main start
Main end
Worker done
Child done

D

Worker done
Child done
Main start
Main end

💡 Hint

Remember that worker threads and child processes run asynchronously, but main thread logs synchronously.

The main thread logs 'Main start' and 'Main end' immediately. Worker thread and child process send messages asynchronously, so their messages appear after main logs.

🔧 Debug

advanced

Identify the error in child process communication

This Node.js code tries to send a message from the parent to the child process. What error will occur when running this code?

Node.js

const { fork } = require('child_process');

const child = fork('child.js');

child.send('Hello parent');

// child.js content:
// process.on('message', msg => {
//   console.log('Message from parent:', msg);
// });

A Error: The child process cannot send messages without a listener in the parent.

B TypeError: child.send is not a function.

C Error: The child process file path is incorrect or missing.

D No error; the message is sent successfully to the child process.

💡 Hint

Check if the parent is sending a message to the child process correctly.

The parent process uses child.send() to send a message to the child process. This works if the child process listens for 'message' events. No error occurs here.

📝 Syntax

advanced

Correct syntax to create a worker thread with inline code

Which option correctly creates a worker thread in Node.js using inline code with the 'eval' option?

A new Worker(`console.log('Hello from worker');`, { eval: true });

B new Worker(`const { parentPort } = require('worker_threads'); parentPort.postMessage('Hi');`, { eval: true });

C new Worker('console.log("Hello from worker")', { eval: true });

D new Worker('const { parentPort } = require('worker_threads'); parentPort.postMessage('Hi');');

💡 Hint

Remember that inline worker code must be a string and use eval: true to run.

Option B correctly uses a template string with inline code and sets eval: true. Option B misses eval: true, so it will error. Options B and C do not use parentPort, so they won't communicate properly.

❓ state_output

expert

State sharing behavior between worker threads and child processes

Given this scenario: A variable 'count' is incremented inside a worker thread and separately inside a child process. After both finish, what are the final values of 'count' in the main thread?

Node.js

let count = 0;

// Worker thread increments count by 1
// Child process increments count by 1

// After both finish, what is count in main thread?

A count is 0 because neither worker thread nor child process can change main thread variables directly.

B count is 1 because only the worker thread shares memory with main thread.

C count is undefined because the variable is not shared at all.

D count is 2 because both increments affect the same variable.

💡 Hint

Think about how memory is shared or isolated between main thread, worker threads, and child processes.

Neither worker threads nor child processes can directly change variables in the main thread. Worker threads share memory but require explicit shared memory objects. Child processes have separate memory. So main thread's 'count' remains unchanged.