What is the difference between blocking and non-blocking (sync vs async) I/O?

Question

IT Interview Practice · Accepted Answer

**Blocking I/O stops the calling thread until the operation finishes; non-blocking I/O returns immediately and lets the thread do other work while the operation completes.** Sync vs async describes the same idea at the API level.

## How it works

- **Blocking / synchronous**: the thread parks on a `read()` until data arrives. Simple, but the thread is idle the whole time — to serve N slow clients you need N threads.
- **Non-blocking / asynchronous**: the call returns at once; the result arrives later via a callback, promise, or event loop notification. One thread can juggle thousands of connections.

```text
Blocking:     ──[ wait for disk ]── (thread stuck, does nothing)
Non-blocking: ──▶ returns now; event loop notified when ready
```

## Example

```js
// Blocking: nothing else runs until the file is read
const data = fs.readFileSync('big.txt');

// Non-blocking: thread keeps going; callback fires later
fs.readFile('big.txt', (err, data) => { /* handle later */ });
// or async/await on top of non-blocking primitives
const data2 = await fs.promises.readFile('big.txt');
```

## Why it matters

This is the core of scalable servers. Node.js and nginx handle huge connection counts on few threads precisely because I/O is non-blocking — waiting doesn't tie up a thread. Use blocking calls for simplicity in scripts; use non-blocking for high-concurrency network services, and never block the event loop with CPU-heavy work.

How it works

Example

Why it matters

Related questions