Single-threaded non-blocking I/O concept in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

How does Node.js handle multiple I/O operations?

Node.js uses a single thread for JavaScript execution. How does it manage to handle multiple I/O operations without blocking the thread?

A It uses multiple threads internally to run JavaScript code in parallel.

B It delegates I/O operations to the system kernel and uses callbacks to handle results asynchronously.

C It queues all I/O operations and runs them one by one synchronously.

D It pauses JavaScript execution until each I/O operation completes.

💡 Hint

Think about how Node.js can keep running code while waiting for files or network responses.

Node.js uses the system kernel to perform I/O operations asynchronously. It registers callbacks that run when the operation finishes, allowing the single JavaScript thread to continue running other code.

❓ component_behavior

intermediate

What is the output order of this Node.js code?

Consider this code snippet: console.log('Start'); setTimeout(() => console.log('Timeout'), 0); console.log('End'); What will be the order of the printed lines?

Node.js

console.log('Start');
setTimeout(() => console.log('Timeout'), 0);
console.log('End');

A Start, Timeout, End

B Timeout, Start, End

C Start, End, Timeout

D End, Start, Timeout

💡 Hint

Remember that setTimeout with 0 delay still runs after the current code finishes.

The synchronous console.log('Start') runs first, then console.log('End'). The setTimeout callback runs last, even with 0 delay, because it is queued in the event loop.

🔧 Debug

advanced

Why does this Node.js code block the event loop?

Look at this code: const fs = require('fs'); const data = fs.readFileSync('file.txt'); console.log('File read'); What is the problem with this code in terms of Node.js single-threaded non-blocking I/O?

Node.js

const fs = require('fs');

const data = fs.readFileSync('file.txt');
console.log('File read');

A readFileSync blocks the event loop until the file is read, stopping other code from running.

B readFileSync runs asynchronously and does not block the event loop.

C The code will throw an error because readFileSync requires a callback.

D The console.log will run before the file is read.

💡 Hint

Check if readFileSync is synchronous or asynchronous.

readFileSync is a synchronous function that blocks the event loop until the file is fully read. This stops other JavaScript code from running during that time.

📝 Syntax

advanced

Which option correctly uses a Promise to read a file asynchronously in Node.js?

You want to read a file asynchronously using Promises. Which code snippet is correct?

A

const fs = require('fs');
const data = fs.readFile('file.txt').then(console.log);

B

const fs = require('fs/promises');
const data = fs.readFileSync('file.txt');
console.log(data);

C

const fs = require('fs');
fs.readFile('file.txt', (err, data) => { if (!err) console.log(data); });

D

const fs = require('fs/promises');
fs.readFile('file.txt').then(data => console.log(data.toString()));

💡 Hint

Look for the correct module and method that returns a Promise.

fs/promises module provides Promise-based versions of fs functions. Using fs.readFile from fs/promises returns a Promise that can be handled with .then().

❓ state_output

expert

What is the output of this Node.js event loop example?

Analyze this code: console.log('1'); setTimeout(() => console.log('2'), 0); Promise.resolve().then(() => console.log('3')); console.log('4');

Node.js

console.log('1');
setTimeout(() => console.log('2'), 0);
Promise.resolve().then(() => console.log('3'));
console.log('4');

A 1, 4, 3, 2

B 1, 3, 4, 2

C 1, 2, 3, 4

D 1, 4, 2, 3

💡 Hint

Remember microtasks (Promises) run before timers in the event loop.

First, synchronous logs '1' and '4' run. Then Promise callbacks (microtasks) run, logging '3'. Finally, setTimeout callbacks (macrotasks) run, logging '2'.

Practice

1. What does it mean that Node.js uses a single-threaded non-blocking I/O model?

easy

A. Node.js blocks the main thread until each task completes.

B. Node.js runs one main thread but can handle many tasks without waiting for each to finish.

C. Node.js uses multiple threads to run tasks in parallel.

D. Node.js cannot handle multiple tasks at the same time.

Solution

1. Step 1: Understand single-threaded meaning

   Node.js runs on one main thread, unlike some systems that use many threads.

2. Step 2: Understand non-blocking I/O meaning

   It does not wait for tasks like file reads to finish before moving on; it uses callbacks or events.

3. Final Answer:

   Node.js runs one main thread but can handle many tasks without waiting for each to finish. -> Option B

4. Quick Check:

   Single-threaded + non-blocking = handle many tasks without waiting [OK]

Hint: Single thread means one main path; non-blocking means no waiting [OK]

Common Mistakes:

• Thinking Node.js uses multiple threads for tasks
• Assuming Node.js waits for each task to finish before continuing
• Confusing blocking with non-blocking I/O

2. Which of the following is the correct way to write a non-blocking file read in Node.js?

easy

A. fs.readFile('file.txt', (err, data) => { if (err) throw err; console.log(data); });

B. const data = fs.readFileSync('file.txt'); console.log(data);

C. const data = fs.readFile('file.txt'); console.log(data);

D. fs.readFile('file.txt'); console.log('done');

Solution

1. Step 1: Identify non-blocking syntax

   Non-blocking file read uses fs.readFile with a callback to handle data after reading.

2. Step 2: Check options for callback usage

   fs.readFile('file.txt', (err, data) => { if (err) throw err; console.log(data); }); uses fs.readFile with a callback function correctly handling error and data.

3. Final Answer:

   fs.readFile('file.txt', (err, data) => { if (err) throw err; console.log(data); }); -> Option A

4. Quick Check:

   Non-blocking file read uses callback = fs.readFile('file.txt', (err, data) => { if (err) throw err; console.log(data); }); [OK]

Hint: Non-blocking uses callbacks, blocking uses sync functions [OK]

Common Mistakes:

• Using synchronous readFileSync for non-blocking tasks
• Calling readFile without a callback
• Expecting immediate data return from async calls

3. What will the following Node.js code output?

console.log('Start');
setTimeout(() => { console.log('Timeout done'); }, 0);
console.log('End');

medium

A. Start\nEnd\nTimeout done

B. End\nStart\nTimeout done

C. Timeout done\nStart\nEnd

D. Start\nTimeout done\nEnd

Solution

1. Step 1: Understand synchronous logs

   console.log('Start') runs immediately and prints 'Start'.

2. Step 2: Understand setTimeout with 0 delay

   setTimeout callback runs after current code finishes, so 'Timeout done' prints last.

3. Step 3: Understand console.log('End')

   This runs immediately after 'Start', printing 'End' before the timeout callback.

4. Final Answer:

   Start End Timeout done -> Option A

5. Quick Check:

   Sync logs first, then async callback = Start\nEnd\nTimeout done [OK]

Hint: setTimeout with 0ms runs after current code finishes [OK]

Common Mistakes:

• Assuming setTimeout runs immediately
• Mixing order of synchronous and asynchronous logs
• Thinking 0ms delay means instant execution

4. Identify the error in this Node.js code snippet using non-blocking I/O:

const fs = require('fs');
let content;
fs.readFile('data.txt', (err, data) => {
  if (err) throw err;
  content = data.toString();
});
console.log(content);

medium

A. The callback function is missing the error parameter.

B. The readFile method should be readFileSync for async code.

C. The variable content is logged before the file read completes.

D. The data.toString() call is invalid.

Solution

1. Step 1: Understand async callback timing

   readFile runs asynchronously, so the callback runs after console.log(content).

2. Step 2: Check when content is logged

   console.log(content) runs immediately, before content is assigned inside the callback.

3. Final Answer:

   The variable content is logged before the file read completes. -> Option C

4. Quick Check:

   Async callback runs later, so content is undefined at log [OK]

Hint: Async callbacks run later; log inside callback to see data [OK]

Common Mistakes:

• Logging async data before callback runs
• Confusing sync and async readFile methods
• Ignoring error parameter in callback

5. You want to read two files in Node.js and then combine their contents. Which approach correctly uses non-blocking I/O to do this?

hard

A. Use fs.readFile once and then read the second file inside the first callback synchronously.

B. Use fs.readFileSync twice and then combine results synchronously.

C. Call fs.readFile twice with callbacks, combine results immediately after calling both without waiting.

D. Call fs.readFile twice with callbacks, combine results inside the second callback only after both finish.

Solution

1. Step 1: Understand non-blocking file reads

   Each fs.readFile runs asynchronously and needs a callback to get data.

2. Step 2: Combine results after both reads finish

   To combine contents, wait for both callbacks to complete, then combine inside the second callback or use coordination logic.

3. Final Answer:

   Call fs.readFile twice with callbacks, combine results inside the second callback only after both finish. -> Option D

4. Quick Check:

   Combine after both async reads finish = Call fs.readFile twice with callbacks, combine results inside the second callback only after both finish. [OK]

Hint: Combine data only after both async callbacks complete [OK]

Common Mistakes:

• Combining data before async reads finish
• Using synchronous reads in async code
• Nesting sync reads inside async callbacks incorrectly