Event Loop Node.js: Fase, nextTick dan setImmediate

Event loop Node.js adalah perulangan yang menentukan callback mana yang berjalan berikutnya setelah kode synchronous-mu selesai. Ia melewati beberapa fase dalam siklus yang tetap: timers (setTimeout, setInterval), pending callbacks, poll (I/O seperti pembacaan file dan data jaringan), check (setImmediate), dan close callbacks. Setelah setiap callback, Node lebih dulu mengosongkan antrean process.nextTick lalu antrean promise, jadi keduanya selalu berjalan sebelum loop lanjut.

// Guess the order of the four lines, then run it
setTimeout(() => console.log('setTimeout'), 0);

Promise.resolve().then(() => console.log('promise'));

process.nextTick(() => console.log('nextTick'));

console.log('sync');

Hasilnya sync, nextTick, promise, setTimeout, kebalikan dari urutan penulisannya. Kode synchronous selalu selesai lebih dulu, lalu Node mengosongkan antrean nextTick, lalu antrean promise, dan baru setelah itu loop dimulai dan sampai ke fase timers.

Fase-fase event loop

Loop milik Node berasal dari libuv, library C yang dipakai Node untuk I/O. Sebelum putaran pertama, ia menjalankan timer yang sudah jatuh tempo, lalu setiap putaran menjalankan fase-fase ini secara berurutan:

1. Pending callbacks: beberapa callback sistem yang ditunda dari putaran sebelumnya, seperti sebagian error jaringan.
2. Poll: event I/O baru dan callback-nya (pembacaan file selesai, data tiba di socket). Saat tidak ada hal lain yang dijadwalkan, loop menunggu di sini.
3. Check: callback setImmediate.
4. Close callbacks: event 'close', seperti socket yang dihancurkan.
5. Timers: callback setTimeout dan setInterval yang waktunya sudah tiba.

Banyak panduan menaruh timers di urutan pertama setiap putaran, dan begitulah cara kerja Node sebelum versi 20 (libuv 1.45). Urutan callback tetap sama di kedua cara: timers dari satu putaran diikuti poll dari putaran berikutnya.

Ada dua antrean di luar fase-fase itu: antrean nextTick dan antrean microtask (callback promise dan queueMicrotask). Node mengosongkan keduanya setelah setiap callback, di fase mana pun, nextTick lebih dulu. Loop terus berputar selama masih ada yang ditunggu (timer, file atau socket yang terbuka, server) dan proses berhenti saat tidak ada lagi yang tersisa.

Ini adalah loop milik Node sendiri. Browser berbagi ide task dan microtask, tetapi tidak punya fase, tidak punya setImmediate, dan tidak punya process.nextTick; halaman event loop JavaScript membahas gambaran di tingkat bahasa.

process.nextTick vs promise

Keduanya berjalan sebelum loop lanjut, tetapi tidak dicampur. Node menjalankan seluruh antrean nextTick, termasuk tick yang ditambahkan selama ia berjalan, baru kemudian antrean promise. Tebak hasilnya:

Promise.resolve()
    .then(() => console.log('promise 1'))
    .then(() => console.log('promise 2'));

process.nextTick(() => {
    console.log('tick 1');
    process.nextTick(() => console.log('tick from tick'));
});
process.nextTick(() => console.log('tick 2'));

Urutannya tick 1, tick 2, tick from tick, promise 1, promise 2. Tick yang dijadwalkan di dalam tick masuk ke antrean yang sama dan tetap berjalan sebelum promise mana pun, walaupun promise-nya dibuat lebih dulu.

Di tingkat atas sebuah ES module (file yang memakai import) keduanya bertukar: kode module itu sendiri berjalan di dalam sebuah promise job, jadi callback promise-nya selesai sebelum Node sampai ke antrean nextTick. Di dalam callback, aturan nextTick-lebih-dulu berlaku di kedua sistem module.

setImmediate vs setTimeout(fn, 0)

setTimeout(fn, 0) sebenarnya berarti "setelah paling sedikit 1 ms, di fase timers". setImmediate(fn) berarti "di fase check berikutnya". Mana yang berjalan lebih dulu tergantung di mana kamu memanggilnya.

Di dalam callback I/O urutannya pasti. Callback itu berjalan di fase poll, fase check datang tepat setelahnya, dan fase timers baru datang sesudah itu:

const fs = require('fs');

fs.readFile(__filename, () => {
    setTimeout(() => console.log('setTimeout'), 0);
    setImmediate(() => console.log('setImmediate'));
    process.nextTick(() => console.log('nextTick'));
});

Hasilnya nextTick, setImmediate, setTimeout, setiap kali. Itulah sebabnya setImmediate adalah pilihan yang tepat untuk "jalankan ini setelah pekerjaan I/O yang sekarang".

Di module utama, di luar callback mana pun, urutan keduanya tidak pasti:

// Order depends on how fast the process started
setTimeout(() => console.log('setTimeout'), 0);
setImmediate(() => console.log('setImmediate'));

Kalau sudah lewat paling sedikit 1 ms saat loop dimulai, timer sudah jatuh tempo dan tercetak lebih dulu; kalau belum, setImmediate yang menang. Jangan menulis kode yang bergantung pada salah satu hasil.

Memblokir event loop

Karena hanya ada satu thread JavaScript, callback yang berjalan lama menghentikan semua yang lain: timer, callback I/O, dan di server, setiap request lain. Delay sebuah timer adalah batas minimum, bukan jaminan.

const start = Date.now();

setTimeout(() => {
    const waited = Date.now() - start;
    console.log('asked for 10 ms, waited 500 ms or more:', waited >= 500);
}, 10);

// A busy loop: holds the thread for half a second
while (Date.now() - start < 500) {}
console.log('loop finished');

loop finished tercetak lebih dulu, lalu true: timer sudah jatuh tempo setelah 10 ms tetapi tidak bisa berjalan sampai busy loop mengembalikan thread. Di server, loop yang sama di dalam route handler membekukan setiap request lain selama setengah detik.

Solusi untuk pekerjaan panjang adalah memecahnya dan memberi loop satu giliran di antara potongan-potongannya dengan setImmediate:

function busy(ms) {
    const end = Date.now() + ms;
    while (Date.now() < end) {}
}

setTimeout(() => console.log('timer'), 0);

function work(part) {
    busy(50);
    console.log('part', part, 'done');
    if (part < 3) setImmediate(() => work(part + 1));
}
work(1);

Timer mendapat giliran setelah part 1. Ganti setImmediate(() => work(part + 1)) dengan work(part + 1) lalu jalankan lagi: ketiga part berjalan sekaligus dan timer tercetak paling akhir.

Untuk pekerjaan yang berat dari awal sampai akhir, seperti pengolahan gambar, memecahnya tidak cukup: pindahkan ke luar main thread dengan worker_threads.

Kesalahan umum

Memanggil process.nextTick secara rekursif. Callback nextTick yang terus menjadwalkan nextTick lain tidak pernah membiarkan loop lanjut, jadi timer dan I/O kelaparan. Pakai setImmediate untuk pekerjaan yang berulang.

Memakai API sync di server. fs.readFileSync, crypto.pbkdf2Sync, dan panggilan JSON.parse yang besar memblokir loop untuk setiap user. Pakai versi async-nya di dalam request handler.

Mengira setTimeout(fn, 0) langsung berjalan. Ia berjalan setelah semua kode synchronous, setiap nextTick, dan setiap callback promise, dan baru setelah loop sampai ke fase timers.