X'inhi d-differenza bejn operazzjonijiet blocking u non-blocking f'Node.js?

Question

IT Interview Practice · Accepted Answer

L-operazzjonijiet **blocking** jaħdmu b'mod sinkroniku u jżommu l-uniku thread ta' JavaScript sakemm jispiċċaw — xejn aktar ma jista' jaħdem sadanittant. L-operazzjonijiet **non-blocking** jibdew ix-xogħol, jirritornaw minnufih, u jwasslu r-riżultat aktar tard permezz ta' callback, Promise, jew event, biex it-thread jibqa' liberu jagħmel affarijiet oħra.

## Għaliex Node huwa single-threaded iżda non-blocking

Il-JavaScript tiegħek jaħdem fuq **thread wieħed** immexxi mill-**event loop**. L-I/O (files, network, DNS) jiġi delegat lil **libuv**, li juża l-faċilitajiet async tal-OS u **thread pool** żgħir taħt il-wiċċ. Waqt li dak ix-xogħol iseħħ barra mit-thread, l-event loop ikompli jipproċessa callbacks oħra. Meta l-I/O jispiċċa, il-callback tiegħu jitqiegħed fil-kju u jiġi eżegwit.

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

// Blocking: il-proċess kollu jistenna hawn; l-ebda request ieħor ma jiġi servut.
const data = fs.readFileSync("big.json");
console.log("done reading");

// Non-blocking: jirritorna minnufih; il-callback jaħdem meta l-I/O jispiċċa.
fs.readFile("big.json", (err, data) => {
  console.log("done reading");
});
console.log("this logs first");
```

## Blocking kontra non-blocking

| | Blocking | Non-blocking |
|---|---|---|
| Stil ta' API | `*Sync` (`readFileSync`) | callback / Promise / `async` |
| Thread | Iżomm l-event loop | Jeħles l-event loop |
| Throughput | Request wieħed kull darba | Ħafna requests fl-istess ħin |
| Uża meta | Skripts ta' startup/CLI | Servers, request handlers |

## Ix-xibka: xogħol CPU-bound xorta jibblokja

Non-blocking jgħin biss bl-**I/O**. Kalkolu sinkroniku tqil (parsing ta' JSON ta' payload enormi, crypto, tibdil tad-daqs ta' immaġni, loop dejjaq) jibblokja l-event loop anke ġewwa funzjoni `async`, għax ix-xogħol tal-CPU nnifsu jaħdem fuq it-thread ta' JS.

```js
// Jibblokja l-event loop għal-loop kollha, minkejja li huwa "async".
async function hash(n) {
  let x = 0;
  for (let i = 0; i < n; i++) x += Math.sqrt(i); // CPU-bound, sinkroniku
  return x;
}
```

Għaddi x-xogħol CPU-bound lil **`worker_threads`**, child process, jew kju biex l-event loop jibqa' responsiv:

```js
const { Worker } = require("node:worker_threads");
new Worker("./cpu-task.js"); // jaħdem fuq thread separat
```

## Regoli prattiċi

- Qatt ma ssejjaħ APIs `*Sync` ġewwa request handler fuq server.
- Uża async I/O kullimkien fil-hot path.
- Ċaqlaq ix-xogħol tqil fuq is-CPU 'l barra mit-thread prinċipali.
- Oqgħod attent għal blocking aċċidentali: `JSON.parse` kbir, crypto sinkroniku, regexes b'catastrophic backtracking.

## Għaliex huwa importanti

Il-mudell tal-prestazzjoni ta' Node jiddependi kompletament fuq li jżomm l-uniku thread tal-event loop liberu. Sejħa blocking waħda mitlufa — `readFileSync`, hash sinkroniku, regex bil-mod — twaqqaf **kull** request simultanju, mhux biss dak li skattah. Li tifhem x'jibblokja u x'ma jibblokjax hija d-differenza bejn server li jiskala għal eluf ta' konnessjonijiet u wieħed li jiffriża taħt il-piż.

	Blocking	Non-blocking
Stil ta' API	`*Sync` (`readFileSync`)	callback / Promise / `async`
Thread	Iżomm l-event loop	Jeħles l-event loop
Throughput	Request wieħed kull darba	Ħafna requests fl-istess ħin
Uża meta	Skripts ta' startup/CLI	Servers, request handlers

Għaliex Node huwa single-threaded iżda non-blocking

Blocking kontra non-blocking

Ix-xibka: xogħol CPU-bound xorta jibblokja

Regoli prattiċi

Għaliex huwa importanti

Mistoqsijiet relatati