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 |
| எப்போது பயன்படுத்த | தொடக்க/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 கொண்ட regex.

## இது ஏன் முக்கியம்

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
எப்போது பயன்படுத்த	தொடக்க/CLI scripts	Servers, request handlers

Node ஏன் single-threaded ஆக இருந்தும் non-blocking ஆக இருக்கிறது

Blocking vs non-blocking

பொறி: CPU-bound வேலை இன்னும் block செய்யும்

கட்டைவிரல் விதிகள்

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்