Event Loop Node.js: Ini Cara Kerja dan Rahasia di Baliknya

Event loop pada Node.js adalah pondasi yang membuat server ini mampu menangani banyak proses tanpa tersendat. Artikel ini akan membantumu memahami bagaimana mekanisme tersebut bekerja dari dalam hingga bagaimana ia menjaga performa aplikasi tetap gesit meskipun hanya dijalankan oleh satu thread.

Apa Itu Event Loop pada Node.js?

Kalau kamu baru mulai terjun ke Node.js, ada satu komponen inti yang perlu dipahami sebelum masuk ke tahap optimasi, scaling, atau deployment, yaitu Event Loop.

Event loop adalah mekanisme kontrol yang mengatur jalannya proses asynchronous dalam Node.js. Mekanisme ini memungkinkan non-blocking I/O, sehingga ketika satu operasi sedang berjalan (misalnya membaca file atau memanggil API), thread utama tidak harus menunggu selesai dulu.

Baca Juga: Baru Belajar? Begini Cara Pahami Loop dalam Pemrograman!

Node cukup menyerahkan tugas itu ke sistem kernel, berjalan terus, dan nanti callback akan dikembalikan ke antrian untuk diproses lagi ketika waktunya tiba.

Yang menarik, event loop ini bukanlah fitur JavaScript semata. Ia adalah bagian dari arsitektur runtime seperti Node.js yang sejak awal dirancang event-driven sehingga mampu menangani puluhan ribu request secara bersamaan melalui satu thread saja.

Baca Juga: Cara Debug Node.js di VS Code: Coba 3 Langkah Efektif Ini!

Secara teknis, event loop hanyalah program C yang terus aktif selama aplikasi Node.js berjalan. Namun dalam praktik, kamu bisa membayangkannya sebagai “orchestrator” yang mengatur bagaimana synchronous code dan asynchronous saling bergantian berjalan tanpa saling menghambat. Itulah rahasia kenapa Node bisa terasa ringan, responsif, dan scalable.

Cara Kerja Event Loop pada Node.js

Sekarang mari masuk ke bagian yang paling penting: bagaimana event loop benar-benar bekerja. Agar lebih mudah dipahami, bayangkan dulu kamu masuk restoran. 

Di dalam restoran tersebut, ada satu pelayan yang mencatat pesananmu dan mengantarkannya ke dapur. Jika pelayan harus menunggu makananmu selesai, ia akan berhenti melayani pelanggan lain. Sistem ini jelas tidak efisien.

Server tradisional seperti Apache pernah punya model seperti itu. Setiap request mendapat satu waitress alias satu thread. Semakin banyak pelanggan, semakin banyak pelayan harus ditambah. Selain mahal, komunikasi antar-thread bisa menimbulkan bug race condition yang cukup sulit ditangani.

Nah, Node.js menyelesaikan masalah itu dengan pendekatan single thread, event-driven, dan asynchronous.

Ketika kamu menjalankan node index.js, Node membuat satu process tempat seluruh thread, memori, dan kode berjalan. Semua fungsi synchronous masuk ke dalam call stack.

Stack ini bekerja seperti antrian: fungsi masuk saat dipanggil, keluar saat selesai dieksekusi. Masalah terjadi jika fungsi berat atau lambat berada di dalamnya, stack berhenti dan request lain tidak bisa dilayani.

Agar tidak macet, Node memanfaatkan API asynchronous (C/C++) dan library bernama libuv, yang bekerja layaknya dapur restoran dengan banyak koki. Tugas berat seperti:

• membaca file (fs.readFile)
• request HTTP
• DNS lookup
• timer (setTimeout, setInterval)
• enkripsi atau kompresi

akan dialihkan ke ruang kerja libuv, mirip seperti koki yang mengambil alih pesanan. Setelah tugas beres, callback dikembalikan ke event queue, menunggu giliran masuk ke call stack. Sementara itu, thread utama tetap bebas melayani request lain.

Tahapan event loop berjalan seperti ini:

1. Initialization
   Node.js memuat file JavaScript, mengeksekusi kode awal, lalu mendaftarkan tugas asynchronous.
2. Execution of Input Script
   Call stack mengeksekusi synchronous code terlebih dahulu dari atas ke bawah.
3. libuv menangani tugas asynchronous
   Operasi berat seperti I/O, network, timer, crypto, dan file system dipindahkan ke thread pool agar tidak memblokir thread utama.
4. Callback masuk ke Event Queue
   Setelah tugas async selesai diproses, callback disimpan dalam event queue sambil menunggu giliran eksekusi.
5. Event Loop memilih callback ketika stack kosong
   Jika call stack tidak lagi memuat tugas, event loop mengambil callback dari queue untuk diproses.
6. Callback dieksekusi sesuai fase event loop
   Callback berjalan mengikuti urutan fase event loop seperti timers → I/O callbacks → poll → check → close callbacks.

Dengan pola ini, server Node.js bisa menangani ribuan koneksi tanpa butuh satu thread per pengguna. Berikut ini visualisasi diagramnya:

Fase-Fase pada Event Loop Node.js

Event loop tidak bekerja secara sembarangan. Ia mengikuti urutan fase yang berulang dan konsisten. Supaya kamu bisa memahami alurnya tanpa pusing, mari kita bahas setiap fase dengan bahasa yang lebih sederhana dan membumi.

1. Timers Phase

Di fase paling awal ini, Node.js mengeksekusi callback yang berasal dari setTimeout() dan setInterval(). Perlu kamu ingat, timer bekerja berdasarkan minimal delay, bukan jaminan waktu pasti. Jadi jika event loop masih sibuk, timer tetap harus menunggu.

2. I/O Callbacks Phase

Setelah timer ditangani, barulah Node memproses callback dari operasi I/O yang sudah selesai sebelumnya. Ini termasuk tugas yang ditunda ke siklus berikutnya seperti error TCP tertentu.

3. Idle, Prepare Phase

Bagian ini bukan konsumsi developer. Node memakainya untuk persiapan internal sebelum masuk ke tahap utama pemrosesan event.

4. Poll Phase

Ini fase inti. Di sinilah sebagian besar operasi I/O diproses. Jika tidak ada tugas yang menunggu, Node bisa berhenti sejenak sambil menunggu event baru, agar lebih menghemat CPU.

5. Check Phase

Callback dari setImmediate() dijalankan di sini. Cocok digunakan ketika kamu butuh eksekusi secepat mungkin setelah poll selesai.

6. Close Callbacks Phase

Tahap terakhir menangani event close, misalnya socket.on(‘close’). Semua koneksi dan handle dilepas secara rapih supaya tidak menimbulkan memory leak.

Satu siklus bisa terjadi ratusan hingga ribuan kali per detik, tergantung banyaknya event yang diproses.

Microtask vs Macrotask: Mana yang Lebih Dulu?

Untuk benar-benar memahami bagaimana Node.js mengatur aliran eksekusi, kamu perlu mengenali dua kelompok tugas utama: macrotask dan microtask. Keduanya adalah fondasi yang memengaruhi urutan kode berjalan. 

Macrotask

Macrotask adalah pekerjaan berskala besar yang diproses per fase event loop. Setiap siklus event loop akan mengambil macrotask satu per satu, menyelesaikannya, lalu baru lanjut ke tugas berikutnya.

Tugas-tugas besar yang diproses di dalam kategori ini:

• setTimeout
• setInterval
• setImmediate
• I/O callback
• eksekusi script utama

Jika kamu merasa program berjalan urut per langkah, sebagian besar sebabnya karena macrotask bergerak lebih terukur dan terstruktur.

Microtask

Sementara itu microtask bekerja seperti VIP lane. Begitu sebuah macrotask selesai, event loop akan menghabiskan seluruh microtask queue terlebih dahulu sebelum pindah fase. Contoh:

• Promise.then(), catch(), finally()
• process.nextTick() (paling tinggi prioritas)

Jadi jika kamu pernah bertanya kenapa Promise sering terlihat lebih cepat dari setTimeout(callback, 0), jawabannya ada di sini, microtask tidak menunggu antrian besar, ia langsung diprioritaskan.

Kenapa Event Loop Sangat Penting Bagi Developer?

Tanpa event loop, Node.js tidak akan seefisien sekarang dalam menangani aplikasi real-time. Untuk membantu kamu melihat nilai praktisnya, mari kita cerna manfaatnya satu per satu.

Non-Blocking I/O

Dengan pola async, Node tidak berhenti hanya karena satu permintaan sedang menunggu respon. Server tetap aktif menerima request lain, sehingga user experience tetap lancar meskipun ada proses berat di belakang layar.

Performa Tinggi & Scalable

Karena tidak butuh banyak thread paralel, server dapat menangani traffic besar tanpa menyedot resource berlebihan. Kamu tidak perlu menambah mesin hanya untuk mengikuti jumlah koneksi.

Concurrency yang Lebih Terkendali

Tidak ada kebutuhan mengelola banyak thread, menghindari potensi race condition yang sering jadi sumber bug sulit dilacak pada aplikasi multithread.

Lebih Hemat Resource

Model single thread dengan dukungan worker pool membuat CPU dan RAM dipakai secara efisien, terutama untuk workload real-time atau API dengan latensi rendah.

Kesimpulan

Event Loop adalah jantung Node.js yang menjaga aplikasi tetap cepat, responsif, dan efisien meskipun hanya berjalan di satu thread. Dengan memahami cara kerjanya, mulai dari call stack, libuv, thread pool, microtask–macrotask, hingga fase-fase event loop, kamu bisa mengembangkan aplikasi yang jauh lebih scalable dan tahan trafik.

Dan kalau kamu ingin memulai proyek Node.js dari nol hingga siap deployment, kamu butuh lingkungan server yang stabil dan fleksibel. IDwebhost menyediakan VPS Murah dengan performa tinggi yang cocok untuk Node.js, lengkap dengan kontrol penuh server dan resource yang bisa kamu scale kapan saja. Cocok untuk belajar, testing, hingga produksi nyata.

Siap mulai bereksperimen dengan Event Loop dan membangun aplikasi scalable-mu sendiri?