Why child processes are needed in Node.js - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use child processes in Node.js?

Why do developers use child processes in Node.js applications?

A To reduce the size of the Node.js application package

B To make the code shorter and easier to read

C To run multiple tasks in parallel without blocking the main event loop

D To automatically fix bugs in the main process

💡 Hint

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

Node.js runs on a single thread, so long-running tasks can block the main event loop. Child processes allow running tasks in parallel, preventing blocking.

❓ component_behavior

intermediate

Behavior of child processes in Node.js

What happens to the main Node.js process when a child process is running a CPU-intensive task?

A The main process slows down but does not crash

B The main process crashes immediately

C The main process pauses until the child process finishes

D The main process continues running smoothly without being blocked

💡 Hint

Child processes run separately from the main process.

Child processes run independently, so the main process stays responsive even during heavy tasks.

📝 Syntax

advanced

Correct way to create a child process in Node.js

Which code snippet correctly creates a child process to run a separate script?

Node.js

const { fork, spawn, exec } = require('child_process');

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

B const child = fork('node script.js');

C const child = exec('fork script.js');

D const child = spawn('node script.js');

💡 Hint

fork() runs a Node.js module as a child process.

fork() is used to create a child process running a Node.js module. spawn() and exec() run commands but require different arguments.

🔧 Debug

advanced

Identify the error in child process communication

What error will occur with this code snippet? const { fork } = require('child_process'); const child = fork('child.js'); child.send('Hello'); // But child.js is missing process.on('message') listener

A The message is sent but not received or logged

B Error: process.send is not a function

C No error, message is received and logged

D SyntaxError due to missing listener

💡 Hint

What happens if the child process does not listen for messages?

If the child process does not listen for messages, the message is sent but ignored silently. No error occurs.

❓ lifecycle

expert

Child process lifecycle and exit codes

What is the correct way to detect if a child process exited successfully in Node.js?

A Listen to the 'close' event and check if exit code is 1

B Listen to the 'exit' event and check if exit code is 0

C Use child.kill() and check for errors

D Check if child process object is null

💡 Hint

Exit code 0 means success in most systems.

The 'exit' event provides the exit code. A code of 0 means the child process ended successfully.

Practice

1. Why do Node.js applications use child processes?

easy

A. To make the app load faster on the internet

B. To reduce the size of the app files

C. To run heavy tasks without freezing the main app

D. To automatically update Node.js version

Solution

1. Step 1: Understand Node.js single-threaded nature

   Node.js runs JavaScript in a single thread, so heavy tasks can block the app.

2. Step 2: Role of child processes

   Child processes run tasks separately, so the main app stays responsive.

3. Final Answer:

   To run heavy tasks without freezing the main app -> Option C

4. Quick Check:

   Child processes prevent freezing = B [OK]

Hint: Child processes keep main app responsive during heavy work [OK]

Common Mistakes:

• Thinking child processes speed up internet loading
• Confusing file size with process management
• Believing child processes update Node.js automatically

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

easy

A. const child = require('child_process').fork('script.js');

B. const child = require('child_process').start('script.js');

C. const child = require('child_process').run('script.js');

D. const child = require('child_process').execute('script.js');

Solution

1. Step 1: Recall Node.js child process methods

   The 'child_process' module has methods like fork(), spawn(), exec(), but not start() or run().

2. Step 2: Identify correct method for creating a child process running a script

   fork() is used to create a new Node.js process running a script file.

3. Final Answer:

   const child = require('child_process').fork('script.js'); -> Option A

4. Quick Check:

   fork() creates child process = A [OK]

Hint: Use fork() to create child Node.js processes [OK]

Common Mistakes:

• Using non-existent methods like start() or run()
• Confusing exec() with fork() for script processes
• Forgetting to require 'child_process' module

3. What will be the output of this Node.js code snippet?

const { fork } = require('child_process');
const child = fork('child.js');
child.on('message', (msg) => {
  console.log('Message from child:', msg);
});
child.send('Hello');

Assuming child.js sends back the message { reply: 'Hi' } when it receives a message.

medium

A. No output because child.js is not executed

B. Message from child: Hello

C. Error: child.send is not a function

D. Message from child: { reply: 'Hi' }

Solution

1. Step 1: Understand message passing between parent and child

   The parent sends 'Hello' to child.js, which replies with { reply: 'Hi' }.

2. Step 2: Check event listener for 'message'

   The parent listens for messages from child and logs them with prefix 'Message from child:'.

3. Final Answer:

   Message from child: { reply: 'Hi' } -> Option D

4. Quick Check:

   Child replies logged correctly = D [OK]

Hint: Child sends message, parent logs with 'Message from child:' prefix [OK]

Common Mistakes:

• Confusing sent and received messages
• Expecting error from child.send() which is valid
• Assuming child.js does not run without error

4. Identify the error in this Node.js code using child processes:

const { fork } = require('child_process');
const child = fork('worker.js');
child.send('start');
child.on('message', (msg) => {
  console.log(msg);
});
child.on('error', (err) => {
  console.error('Child error:', err);
});

medium

A. Calling child.send() before setting up 'message' event listener

B. No error; code is correct

C. Not handling 'exit' event of child process

D. Missing require statement for 'child_process' module

Solution

1. Step 1: Check order of send() and event listeners

   It's valid to call send() before setting up 'message' listener; messages will queue.

2. Step 2: Verify required event handlers and module import

   Module is required correctly; 'error' event is handled; 'exit' event is optional.

3. Final Answer:

   No error; code is correct -> Option B

4. Quick Check:

   Code follows child process patterns = C [OK]

Hint: send() can be called anytime; event listeners catch messages/errors [OK]

Common Mistakes:

• Thinking send() must come after 'message' listener
• Expecting mandatory 'exit' event handling
• Missing module import (not in this code)

5. You want to perform a CPU-heavy task in Node.js without blocking the main event loop. Which approach best uses child processes to achieve this?

hard

A. Use fork() to run the heavy task in a separate process and communicate results via messages

B. Run the heavy task directly in the main thread and use setTimeout to delay it

C. Use exec() to run a shell command that blocks the main thread

D. Use require() to load the heavy task module synchronously

Solution

1. Step 1: Identify how to avoid blocking main event loop

   Heavy CPU tasks block the single-threaded main loop, causing freezes.

2. Step 2: Use child processes to run heavy tasks separately

   fork() creates a separate Node.js process to run the task without blocking.

3. Step 3: Communicate results safely

   Use message passing between main and child process to get results asynchronously.

4. Final Answer:

   Use fork() to run the heavy task in a separate process and communicate results via messages -> Option A

5. Quick Check:

   fork() isolates heavy tasks = A [OK]

Hint: fork() runs heavy tasks separately, keeping main loop free [OK]

Common Mistakes:

• Using setTimeout to delay heavy tasks (does not prevent blocking)
• Using exec() which can block main thread
• Loading heavy tasks synchronously with require()