Node.js లో blocking మరియు non-blocking ఆపరేషన్ల మధ్య తేడా ఏమిటి?

Question

IT Interview Practice · Accepted Answer

**Blocking** ఆపరేషన్లు synchronous గా అమలవుతాయి మరియు అవి పూర్తయ్యే వరకు ఒకే JavaScript thread ను పట్టుకుని ఉంచుతాయి — ఈ మధ్యలో మరేదీ అమలు కాదు. **Non-blocking** ఆపరేషన్లు పనిని ప్రారంభించి, వెంటనే తిరిగి వస్తాయి, మరియు ఫలితాన్ని తర్వాత ఒక callback, Promise, లేదా event ద్వారా అందిస్తాయి, కాబట్టి thread ఇతర పనులు చేయడానికి ఖాళీగా ఉంటుంది.

## Node single-threaded అయినా non-blocking ఎందుకు

మీ JavaScript **event loop** చే నడిపించబడే **ఒకే** thread పై అమలవుతుంది. I/O (files, network, DNS) **libuv** కు అప్పగించబడుతుంది, ఇది లోపల OS యొక్క async సౌకర్యాలను మరియు ఒక చిన్న **thread pool** ను ఉపయోగిస్తుంది. ఆ పని thread కు వెలుపల జరుగుతున్నప్పుడు, event loop ఇతర callbacks ను ప్రాసెస్ చేస్తూనే ఉంటుంది. I/O పూర్తయినప్పుడు, దాని callback వరుసలో చేర్చబడి అమలవుతుంది.

```js
const fs = require("node:fs");

// Blocking: మొత్తం process ఇక్కడ వేచి ఉంటుంది; మరే request కు సేవ అందదు.
const data = fs.readFileSync("big.json");
console.log("done reading");

// Non-blocking: వెంటనే తిరిగి వస్తుంది; I/O పూర్తయినప్పుడు callback అమలవుతుంది.
fs.readFile("big.json", (err, data) => {
  console.log("done reading");
});
console.log("this logs first");
```

## Blocking vs non-blocking

| | Blocking | Non-blocking |
|---|---|---|
| API శైలి | `*Sync` (`readFileSync`) | callback / Promise / `async` |
| Thread | event loop ను పట్టుకుంటుంది | event loop ను విడుదల చేస్తుంది |
| Throughput | ఒకసారి ఒక request | అనేక ఏకకాల requests |
| ఎప్పుడు వాడాలి | Startup/CLI scripts | Servers, request handlers |

## ఉచ్చు: CPU-bound పని ఇంకా block చేస్తుంది

Non-blocking కేవలం **I/O** తో మాత్రమే సహాయపడుతుంది. ఒక భారీ synchronous గణన (పెద్ద payload ను JSON parse చేయడం, crypto, image resizing, ఒక బిగుతైన loop) `async` function లోపల కూడా event loop ను block చేస్తుంది, ఎందుకంటే CPU పని స్వయంగా JS thread పై అమలవుతుంది.

```js
// "async" అయినప్పటికీ, మొత్తం loop కు event loop ను block చేస్తుంది.
async function hash(n) {
  let x = 0;
  for (let i = 0; i < n; i++) x += Math.sqrt(i); // CPU-bound, synchronous
  return x;
}
```

event loop ప్రతిస్పందించే స్థితిలో ఉండేలా CPU-bound పనిని **`worker_threads`**, ఒక child process, లేదా ఒక queue కు తరలించండి:

```js
const { Worker } = require("node:worker_threads");
new Worker("./cpu-task.js"); // ఒక వేరే thread పై అమలవుతుంది
```

## మౌలిక సూత్రాలు

- server పై request handler లోపల `*Sync` API లను ఎప్పుడూ పిలవవద్దు.
- hot path లో ప్రతిచోటా async I/O ను ఉపయోగించండి.
- CPU-భారీ పనిని main thread నుండి తరలించండి.
- అనుకోని blocking పట్ల జాగ్రత్త వహించండి: పెద్ద `JSON.parse`, synchronous crypto, catastrophic backtracking ఉన్న regexes.

## ఇది ఎందుకు ముఖ్యం

Node యొక్క పనితీరు నమూనా పూర్తిగా ఒకే event-loop thread ను ఖాళీగా ఉంచడంపై ఆధారపడి ఉంటుంది. ఒక తప్పిపోయిన blocking కాల్ — ఒక `readFileSync`, ఒక synchronous hash, ఒక నెమ్మదైన regex — దాన్ని ప్రేరేపించిన request ను మాత్రమే కాదు, **ప్రతి** ఏకకాల request ను స్తంభింపజేస్తుంది. ఏది block చేస్తుంది, ఏది చేయదు అనేది అర్థం చేసుకోవడం వేల కనెక్షన్ల వరకు స్కేల్ అయ్యే server కు, భారం కింద గడ్డకట్టే server కు మధ్య తేడా.

	Blocking	Non-blocking
API శైలి	`*Sync` (`readFileSync`)	callback / Promise / `async`
Thread	event loop ను పట్టుకుంటుంది	event loop ను విడుదల చేస్తుంది
Throughput	ఒకసారి ఒక request	అనేక ఏకకాల requests
ఎప్పుడు వాడాలి	Startup/CLI scripts	Servers, request handlers

Node single-threaded అయినా non-blocking ఎందుకు

Blocking vs non-blocking

ఉచ్చు: CPU-bound పని ఇంకా block చేస్తుంది

మౌలిక సూత్రాలు

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు