કયા પ્રકારની ઓપરેશન Node.js ના event loop ને બ્લોક કરે છે?

Question

IT Interview Practice · Accepted Answer

Event loop તમારા JavaScript ને **એક જ thread** પર ચલાવે છે, તેથી કોઈપણ **synchronous** વસ્તુ જે લાંબો સમય લે છે તે તેને બ્લોક કરે છે — અને બ્લોક હોય ત્યારે, Node બીજી કોઈ request, timer કે callback ને સેવા આપતું નથી. બ્લોકિંગ લગભગ હંમેશા **CPU-bound કામ** અથવા **`*Sync` API** હોય છે, ક્યારેય યોગ્ય રીતે await કરેલ async I/O નહીં.

## તેને શું અવરોધે છે

- **Synchronous (`*Sync`) API** — `fs.readFileSync`, `fs.writeFileSync`, `child_process.execSync`, `zlib.gzipSync`. તેઓ libuv ને સોંપવાને બદલે ત્યાં જ રાહ જુએ છે.
- **ભારે CPU ગણતરી** — ચુસ્ત loops, મોટા array પર `map`/`sort`/`filter`, matrix ગણિત, image/video પ્રોસેસિંગ, વિશાળ structures ને parse/serialize કરવું.
- **મોટા `JSON.parse` / `JSON.stringify`** — synchronous અને O(n); થોડા MB નો payload આખા parse દરમિયાન loop ને થીજવી દે છે.
- **Synchronous crypto** — `crypto.pbkdf2Sync`, `bcrypt` sync mode, main thread પર મોટા buffers ને hash કરવું.
- **વિનાશક regex backtracking (ReDoS)** — પ્રતિકૂળ input પર એક રોગગ્રસ્ત pattern એક જ string પર સેકન્ડો સુધી અટકી શકે છે.
- **લાંબા synchronous loops** — `while (true)`, અમર્યાદ recursion, દરેક item દીઠ કામ સાથે લાખો items પર `for`.

```js
// આ બધું loop ને બ્લોક કરે છે — તે દરમિયાન બીજી કોઈ request ને સેવા મળતી નથી:
const data = fs.readFileSync("big.json");     // sync I/O
const obj = JSON.parse(hugeString);            // મોટું parse
const hash = crypto.pbkdf2Sync(pw, salt, 1e6, 64, "sha512"); // sync crypto
for (let i = 0; i < 1e9; i++) { /* CPU */ }    // ચુસ્ત loop
```

> CPU કામને `async` function માં લપેટવાથી કંઈ મદદ **નથી** થતી — `async` માત્ર `await` પર જ નિયંત્રણ છોડે છે; synchronous body હજુ પણ loop thread પર પૂરી થાય ત્યાં સુધી ચાલે છે.

## તેને કેવી રીતે શોધવું

- **Event-loop lag** — `perf_hooks.monitorEventLoopDelay()` અથવા `blocked-at` જેવી libraries થી માપો; વધતો lag એટલે કંઈક thread ને પકડી રાખ્યું છે.
- **Profilers** — hot synchronous frame શોધવા માટે `node --prof`, `clinic doctor`/`clinic flame`, Chrome DevTools CPU profile.

## તેને કેવી રીતે ઠીક કરવું

- દરેક `*Sync` call ના **async** સમકક્ષનો ઉપયોગ કરો (`fs.promises.readFile`, `crypto.pbkdf2`, `zlib.gzip`).
- CPU-bound કામને **`worker_threads`** pool, child process, અથવા બાહ્ય queue/service પર ખસેડો.
- લાંબા loops ને `setImmediate`/`await` વડે **ટુકડાઓમાં** વહેંચો જેથી loop batches વચ્ચે શ્વાસ લઈ શકે.
- મોટા data ને એકસાથે buffer + parse કરવાને બદલે **stream** કરો.
- regex ને મર્યાદિત અને સ્વચ્છ કરો; linear-time patterns ને પ્રાધાન્ય આપો.

```js
const { Worker } = require("node:worker_threads");
// ખર્ચાળ hash ને offload કરો જેથી loop responsive રહે.
const worker = new Worker("./hash-worker.js", { workerData: { pw, salt } });
```

## આ શા માટે મહત્વનું છે

Node માં, એક બ્લોકિંગ call **દરેક** સમવર્તી client ને સજા કરે છે, માત્ર તે request ને નહીં જેણે તેને પેદા કર્યું — latency ઊછળે છે, health checks time out થાય છે, અને process load હેઠળ "hung" દેખાય છે. ઇન્ટરવ્યુઅર્સ આ પૂછે છે એ જોવા માટે કે તમે નક્કર બ્લોકર્સ (`*Sync`, મોટું `JSON.parse`, sync crypto, ReDoS, CPU loops) નામ આપી શકો, event-loop-lag tooling થી તેમને શોધી શકો, અને async પર જઈને કે worker threads પર offload કરીને તેમને ઠીક કરી શકો. તે production માં સૌથી સામાન્ય Node performance નિષ્ફળતા છે.

તેને શું અવરોધે છે

તેને કેવી રીતે શોધવું

તેને કેવી રીતે ઠીક કરવું

આ શા માટે મહત્વનું છે

સંબંધિત પ્રશ્નો