How Node.js Handles OS Interaction, Single Threading, and Event Loop

Introduction

Node.js is described as an event‑driven, non‑blocking I/O JavaScript runtime built on Chrome’s V8 engine, offering lightweight and efficient execution. Common questions include why JavaScript can perform low‑level OS interactions, whether Node.js is truly single‑threaded, how it handles high concurrency, and how its event‑driven model works.

Architecture Overview

The core consists of three layers:

Node.js standard library written in JavaScript (exposed APIs in the lib directory).

Node bindings that bridge JavaScript to native C/C++ code (implemented in node.cc ).

Underlying C/C++ implementation providing the runtime.

Key components include:

V8 : Google’s JavaScript engine that runs JS outside the browser.

libuv : Provides cross‑platform thread pool, event queue, and asynchronous I/O.

C‑ares : Handles asynchronous DNS.

http_parser, OpenSSL, zlib : Offer HTTP parsing, SSL, and compression.

Interaction with the Operating System

Example of opening a file:

<code>var fs = require('fs');
fs.open('./test.txt', "w", function(err, fd) { /*..do something*/ });</code>

The call flow is

lib/fs.js → src/node_file.cc → uv_fs

. The relevant source snippets are shown below.

<code>async function open(path, flags, mode) {
  mode = modeNum(mode, 0o666);
  path = getPathFromURL(path);
  validatePath(path);
  validateUint32(mode, 'mode');
  return new FileHandle(
    await binding.openFileHandle(pathModule.toNamespacedPath(path),
                               stringToFlags(flags),
                               mode, kUsePromises));
}
</code>

<code>static void Open(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  int argc = args.Length();
  if (req_wrap_async != nullptr) {
    AsyncCall(env, req_wrap_async, args, "open", UV_RUN_DEFAULT, AfterInteger,
              uv_fs_open, *path, flags, mode);
  } else {
    CHECK_EQ(argc, 5);
    FSReqWrapSync req_wrap_sync;
    int result = SyncCall(env, args[4], &req_wrap_sync, "open",
                         uv_fs_open, *path, flags, mode);
    args.GetReturnValue().Set(result);
  }
}
</code>

<code>int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, int mode, uv_fs_cb cb) {
  /* ... */
}
</code>

Thus, JavaScript calls ultimately reach the OS through

process.binding

, which forwards them to the native C/C++ layer.

Single‑Threaded Model

Traditional web servers use multiple threads to avoid blocking I/O. Node.js runs JavaScript on a single main thread; synchronous code blocks this thread, preventing other requests from being processed until the block completes.

<code>var http = require('http');
function sleep(time) {
  var _exit = Date.now() + time * 1000;
  while (Date.now() < _exit) {}
  return;
}
var server = http.createServer(function(req, res) {
  sleep(10);
  res.end('server sleep 10s');
});
server.listen(8080);
</code>

When the server receives a request, the blocking

sleep

pushes the request onto the call stack, causing subsequent requests to wait, illustrating why pure single‑threaded execution would be inefficient without asynchronous handling.

Event‑Driven / Event Loop

Node.js uses libuv’s event loop to schedule asynchronous work. The loop consists of six phases:

timers : Executes callbacks from

setTimeout

and

setInterval

.

I/O callbacks : Handles some system call errors.

idle, prepare : Internal use.

poll : Retrieves new I/O events; may block.

check : Executes

setImmediate

callbacks.

close callbacks : Runs callbacks for closed handles.

The core loop is implemented in

uv_run

:

<code>int uv_run(uv_loop_t* loop, uv_run_mode mode) {
  int r = uv__loop_alive(loop);
  while (r != 0 && loop->stop_flag == 0) {
    uv__update_time(loop);
    uv__run_timers(loop);
    int ran_pending = uv__run_pending(loop);
    uv__run_idle(loop);
    uv__run_prepare(loop);
    int timeout = 0;
    if ((mode == UV_RUN_ONCE && !ran_pending) || mode == UV_RUN_DEFAULT)
      timeout = uv_backend_timeout(loop);
    uv__io_poll(loop, timeout);
    uv__run_check(loop);
    uv__run_closing_handles(loop);
    if (mode == UV_RUN_ONCE) {
      uv__update_time(loop);
      uv__run_timers(loop);
    }
    r = uv__loop_alive(loop);
    if (mode == UV_RUN_ONCE || mode == UV_RUN_NOWAIT) break;
  }
  return r;
}
</code>

Supporting functions such as

uv_backend_timeout

and

uv__next_timeout

determine how long the poll phase should wait based on active handles, pending requests, and timers.

Summary

1. Node.js interacts with the OS by routing JavaScript calls through

process.binding

to native C/C++ implementations.

2. The “single‑threaded” claim refers only to the JavaScript main thread; actual I/O and network work is performed by libuv’s thread pool.

3. High concurrency is achieved thanks to libuv’s event‑loop mechanism and its efficient handling of asynchronous tasks.

4. The event loop runs through seven stages (timers, I/O callbacks, idle/prepare, poll, check, close callbacks), repeatedly processing each stage to complete a tick.