Apa perbedaan antara operasi blocking dan non-blocking di Node.js?

Question

IT Interview Practice · Accepted Answer

Operasi **blocking** berjalan secara sinkron dan menahan satu-satunya thread JavaScript sampai selesai — tidak ada hal lain yang bisa berjalan sementara itu. Operasi **non-blocking** memulai pekerjaan, langsung kembali, dan menyampaikan hasilnya kemudian melalui callback, Promise, atau event, sehingga thread tetap bebas mengerjakan hal lain.

## Mengapa Node single-threaded tetapi non-blocking

JavaScript Anda berjalan di **satu** thread yang dikendalikan oleh **event loop**. I/O (berkas, jaringan, DNS) didelegasikan ke **libuv**, yang memakai fasilitas async OS dan sebuah **thread pool** kecil di baliknya. Selagi pekerjaan itu berlangsung di luar thread, event loop terus memproses callback lain. Ketika I/O selesai, callback-nya diantrikan dan dijalankan.

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

// Blocking: seluruh proses menunggu di sini; tidak ada request lain yang dilayani.
const data = fs.readFileSync("big.json");
console.log("done reading");

// Non-blocking: langsung kembali; callback berjalan saat I/O selesai.
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 | Menahan event loop | Membebaskan event loop |
| Throughput | Satu request pada satu waktu | Banyak request bersamaan |
| Dipakai saat | Skrip startup/CLI | Server, request handler |

## Jebakannya: pekerjaan CPU-bound tetap memblokir

Non-blocking hanya membantu untuk **I/O**. Komputasi sinkron yang berat (mem-parse JSON payload raksasa, kriptografi, mengubah ukuran gambar, loop yang ketat) memblokir event loop bahkan di dalam fungsi `async`, karena pekerjaan CPU itu sendiri berjalan di thread JS.

```js
// Memblokir event loop selama seluruh loop, meski ditandai "async".
async function hash(n) {
  let x = 0;
  for (let i = 0; i < n; i++) x += Math.sqrt(i); // CPU-bound, sinkron
  return x;
}
```

Pindahkan pekerjaan CPU-bound ke **`worker_threads`**, sebuah child process, atau sebuah queue agar event loop tetap responsif:

```js
const { Worker } = require("node:worker_threads");
new Worker("./cpu-task.js"); // berjalan di thread terpisah
```

## Aturan praktis

- Jangan pernah memanggil API `*Sync` di dalam request handler pada server.
- Gunakan I/O async di mana pun pada hot path.
- Pindahkan pekerjaan berat CPU keluar dari main thread.
- Waspadai blocking tak sengaja: `JSON.parse` besar, kriptografi sinkron, regex dengan catastrophic backtracking.

## Mengapa ini penting

Model performa Node sepenuhnya bergantung pada menjaga satu-satunya thread event loop tetap bebas. Satu panggilan blocking yang tersasar — sebuah `readFileSync`, sebuah hash sinkron, sebuah regex lambat — menghentikan **setiap** request bersamaan, bukan hanya yang memicunya. Memahami apa yang memblokir dan apa yang tidak adalah pembeda antara server yang menskala ke ribuan koneksi dan server yang membeku di bawah beban.

	Blocking	Non-blocking
Gaya API	`*Sync` (`readFileSync`)	callback / Promise / `async`
Thread	Menahan event loop	Membebaskan event loop
Throughput	Satu request pada satu waktu	Banyak request bersamaan
Dipakai saat	Skrip startup/CLI	Server, request handler

Mengapa Node single-threaded tetapi non-blocking

Blocking vs non-blocking

Jebakannya: pekerjaan CPU-bound tetap memblokir

Aturan praktis

Mengapa ini penting

Pertanyaan terkait