Apa bedane operasi blocking lan non-blocking ing Node.js?

Question

IT Interview Practice · Accepted Answer

Operasi **blocking** mlaku kanthi sinkron lan nyekel siji-sijine thread JavaScript nganti rampung — sasuwene iku ora ana liyane sing bisa mlaku. Operasi **non-blocking** miwiti gaweyan, langsung bali, banjur nyerahake asile mengko liwat callback, Promise, utawa event, mula thread tetep bebas nggarap perkara liya.

## Kenapa Node single-threaded nanging non-blocking

JavaScript sampeyan mlaku ing **siji** thread sing disetir dening **event loop**. I/O (berkas, jaringan, DNS) didelegasikake menyang **libuv**, sing nganggo fasilitas async OS lan **thread pool** cilik ing mburi. Sasuwene gaweyan iku mlaku ing njaba thread, event loop terus ngolah callback liyane. Nalika I/O rampung, callback-e diantre lan dijalanake.

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

// Blocking: kabeh proses ngenteni ing kene; ora ana request liya sing dilayani.
const data = fs.readFileSync("big.json");
console.log("done reading");

// Non-blocking: langsung bali; callback mlaku nalika I/O rampung.
fs.readFile("big.json", (err, data) => {
  console.log("done reading");
});
console.log("this logs first");
```

## Blocking vs non-blocking

| | Blocking | Non-blocking |
|---|---|---|
| Gaya API | `*Sync` (`readFileSync`) | callback / Promise / `async` |
| Thread | Nyekel event loop | Mbebasake event loop |
| Throughput | Siji request saben wektu | Akeh request bebarengan |
| Dianggo nalika | Skrip startup/CLI | Server, request handler |

## Jebakane: gaweyan CPU-bound tetep mblokir

Non-blocking mung mbantu kanggo **I/O**. Petungan sinkron sing abot (mem-parse JSON payload gedhe banget, kriptografi, ngowahi ukuran gambar, loop sing rapet) mblokir event loop malah ing njero fungsi `async`, amarga gaweyan CPU dhewe mlaku ing thread JS.

```js
// Mblokir event loop sasuwene kabeh loop, senajan ditandhani "async".
async function hash(n) {
  let x = 0;
  for (let i = 0; i < n; i++) x += Math.sqrt(i); // CPU-bound, sinkron
  return x;
}
```

Pindhahna gaweyan CPU-bound menyang **`worker_threads`**, sawijining child process, utawa sawijining queue supaya event loop tetep responsif:

```js
const { Worker } = require("node:worker_threads");
new Worker("./cpu-task.js"); // mlaku ing thread kapisah
```

## Paugeran praktis

- Aja tau nyeluk API `*Sync` ing njero request handler ing server.
- Nganggo I/O async ing ngendi wae ing hot path.
- Pindhahna gaweyan abot CPU metu saka main thread.
- Ati-ati marang blocking sing ora disengaja: `JSON.parse` gedhe, kriptografi sinkron, regex kanthi catastrophic backtracking.

## Kenapa iki penting

Model kinerja Node gumantung sakabehe marang njaga siji-sijine thread event loop supaya tetep bebas. Mung siji panggilan blocking sing kesasar — sawijining `readFileSync`, sawijining hash sinkron, sawijining regex alon — mandhegake **saben** request bebarengan, ora mung sing njalari. Ngerti apa sing mblokir lan apa sing ora yaiku pambeda antarane server sing skala tekan ewonan koneksi lan server sing beku ing sangisore beban.

	Blocking	Non-blocking
Gaya API	`*Sync` (`readFileSync`)	callback / Promise / `async`
Thread	Nyekel event loop	Mbebasake event loop
Throughput	Siji request saben wektu	Akeh request bebarengan
Dianggo nalika	Skrip startup/CLI	Server, request handler

Kenapa Node single-threaded nanging non-blocking

Blocking vs non-blocking

Jebakane: gaweyan CPU-bound tetep mblokir

Paugeran praktis

Kenapa iki penting

Pitakon sing gegandhengan