发布于 由admin

Node.js 启动流程：从 C++ `node::Start()` 到用户代码执行

各位编程爱好者，大家好！

今天我们将深入探讨 Node.js 的启动流程，这是一个既复杂又迷人的主题。从我们在命令行敲下 node app.js 的那一刻起，到我们的 JavaScript 代码真正开始执行，这背后经历了 C++、V8 引擎、libuv 事件循环以及 Node.js 核心模块的协同工作。理解这个过程，不仅能帮助我们更好地调试和优化 Node.js 应用，还能深化我们对整个运行时环境的认识。

我们将从 Node.js 的 C++ 启动入口 node::Start() 开始，逐步揭示 V8 引擎的初始化、libuv 事件循环的建立、Node.js 环境对象的构建、内置模块的加载，直至最终用户 JavaScript 代码的执行。

Node.js 启动的宏观视角

Node.js 的核心架构可以概括为以下几个主要组件：

  • V8 JavaScript 引擎：负责解析、编译和执行 JavaScript 代码。
  • libuv 库：提供跨平台的异步 I/O 和事件循环能力。它抽象了操作系统底层的非阻塞 I/O 操作，使得 Node.js 能够高效处理并发连接。
  • C++ 核心模块：实现了 Node.js 的大部分底层功能，例如文件系统、网络、HTTP 等，并通过 V8 的 FFI（Foreign Function Interface）或 C++ bindings 暴露给 JavaScript。
  • JavaScript 核心模块：位于 lib/ 目录下，由纯 JavaScript 实现，构建在 C++ 核心模块之上，提供了更高级别的 API。

当一个 Node.js 进程启动时，它首先是一个标准的 C++ 应用程序。这个 C++ 应用程序负责初始化 V8 引擎、设置事件循环、加载 Node.js 的内置模块，并最终将控制权交给 JavaScript。

整个启动流程可以概括为：

  1. C++ 初始化：解析命令行参数，初始化 V8 和 libuv。
  2. 环境构建：创建 Node.js 运行时环境对象 (node::Environment) 和 V8 上下文 (v8::Context)。
  3. 内置模块加载：将 Node.js 的 C++ 内置绑定和 JavaScript 内置模块 (internal/*) 注入到 V8 上下文中。
  4. JavaScript 引导：执行 Node.js 的 JavaScript 引导代码 (internal/bootstrap/node.js)，设置 process、global 等全局对象。
  5. 用户代码执行：加载并执行用户提供的 JavaScript 入口文件。
  6. 事件循环：进入 libuv 事件循环，处理异步事件。

接下来，我们将逐一深入这些步骤。

C++ 世界的入口：node::Start()

Node.js 应用程序的生命周期始于 C++ 端的 main 函数。在 src/node_main.cc 文件中，我们可以找到这个入口点。它的主要职责是解析命令行参数，设置 V8 和 Node.js 的全局配置，然后调用 node::Start() 函数。

// src/node_main.cc

// ... 其他包含和定义

int main(int argc, char* argv[]) {
  // 1. 设置 V8 的标志，例如垃圾回收、调试等
  // v8::V8::SetFlagsFromCommandLine(&argc, argv, true);

  // 2. 将命令行参数传递给 Node.js 的启动函数
  std::vector<std::string> args(argv, argv + argc);
  std::vector<std::string> exec_args; // 存储 Node.js 运行时参数，例如 --inspect

  // ParseArgs 是一个辅助函数，用于区分 Node.js 运行时参数和用户脚本参数
  // node::ParseArgs(&args, &exec_args);

  // 3. 调用 node::Start() 函数
  int exit_code = node::Start(args, exec_args);

  return exit_code;
}

node::Start() 函数（位于 src/node.cc）是 Node.js 启动流程中至关重要的一环。它负责：

  1. 初始化 V8 平台：为 V8 引擎提供必要的服务，如任务调度、内存分配。
  2. 创建 V8 实例：创建 v8::Isolate，这是 V8 引擎的一个独立运行实例。
  3. 创建 Node.js 环境：构建 node::Environment 对象，它封装了 V8 实例、事件循环、上下文等 Node.js 运行所需的所有状态。
  4. 加载内置模块：将 Node.js 的 C++ 绑定和 JavaScript 内置模块加载到环境中。
  5. 执行 JavaScript 引导代码：运行 internal/bootstrap/node.js。
  6. 执行用户代码：加载并执行用户提供的 JavaScript 文件。
  7. 进入事件循环：启动 libuv 事件循环，使 Node.js 能够处理异步事件。

让我们逐步拆解 node::Start() 的内部细节。

// src/node.cc

namespace node {

// ... 其他辅助函数和定义

int Start(const std::vector<std::string>& args,
          const std::vector<std::string>& exec_args) {
  // 1. 初始化 V8 平台
  // Node.js 提供了一个 V8::Platform 的实现，用于处理 V8 的异步任务、计时器等
  std::unique_ptr<v8::Platform> platform = V8Platform::Create();
  v8::V8::InitializePlatform(platform.get());
  v8::V8::Initialize(); // 初始化 V8 引擎

  // 2. 创建 V8 Isolate
  // Isolate 是 V8 的一个独立运行实例，拥有自己的堆和垃圾回收器
  std::unique_ptr<v8::Isolate> isolate = NewIsolate();
  if (!isolate) {
    // 错误处理
    return 1;
  }

  // 3. 设置 Isolate 的委托（Delegate）
  // 用于处理 Promise 拒绝、错误捕获等
  SetIsolateDelegate(isolate.get(), platform.get());

  // 4. 初始化 UV 循环
  // Node.js 的事件循环是由 libuv 提供的
  uv_loop_t default_loop;
  int err = uv_loop_init(&default_loop);
  if (err) {
    // 错误处理
    return 1;
  }

  // 5. 创建 Node.js 环境
  // Environment 是 Node.js 运行时的核心对象，封装了 Isolate, Context, uv_loop_t 等
  std::unique_ptr<Environment> env =
      CreateEnvironment(isolate.get(), &default_loop, args, exec_args);
  if (!env) {
    // 错误处理
    return 1;
  }

  // 6. 加载内置模块
  // 这会将 Node.js 的 C++ 绑定和 JavaScript 内置模块注册到环境中
  loader::InitializeBuiltinModules(env.get());

  // 7. 执行 Environment 的初始化，包括运行 JavaScript 引导代码
  // 这会执行 internal/bootstrap/node.js
  LoadEnvironment(env.get());

  // 8. 启动事件循环，开始处理异步操作
  int exit_code = uv_run(&default_loop, UV_RUN_DEFAULT);

  // 9. 关闭事件循环和清理资源
  uv_loop_close(&default_loop);

  // ... 清理 V8 资源

  return exit_code;
}

} // namespace node

从上述代码中，我们可以看到 node::Start() 串联起了 V8 引擎的初始化、libuv 事件循环的建立以及 Node.js 运行时环境的创建。

V8 引擎的初始化与配置

V8 是 Node.js 的 JavaScript 执行引擎。在 Node.js 启动之初，必须对其进行初始化和配置。这涉及到 v8::Platform、v8::Isolate 和 v8::ArrayBuffer::Allocator 的创建。

v8::Platform

v8::Platform 是 V8 引擎与宿主环境（Node.js 在此）之间的一个接口。它允许宿主环境为 V8 提供一些平台相关的服务，例如：

  • 任务调度：V8 内部会有一些后台任务（如垃圾回收的并发标记），需要平台来调度执行。
  • 线程池：提供执行这些任务的线程。
  • 计时器：用于 V8 内部的定时操作。
  • 跟踪：用于性能分析和调试。

Node.js 实现了自己的 V8Platform 类（在 src/node_platform.cc 中），它利用 libuv 来调度任务和管理线程池。

// src/node.cc (片段)
// ...
std::unique_ptr<v8::Platform> platform = V8Platform::Create();
v8::V8::InitializePlatform(platform.get()); // 将 Node.js 的平台实现告知 V8
v8::V8::Initialize();                       // 初始化 V8 引擎
// ...

v8::Isolate

v8::Isolate 是 V8 引擎的一个独立运行实例。每个 Isolate 都拥有自己的堆内存、垃圾回收器和全局对象。这意味着在同一个进程中可以运行多个 Isolate，它们之间是完全隔离的，互不影响。Node.js 的主线程通常只使用一个 Isolate，但在 Worker Threads 等场景下会创建新的 Isolate。

node::NewIsolate() 函数负责创建并配置这个 Isolate。

// src/node.cc (片段)
std::unique_ptr<v8::Isolate> NewIsolate() {
  // 1. 创建 ArrayBuffer Allocator
  // 用于 V8 内部的 ArrayBuffer 内存分配，Node.js 使用自己的实现来优化内存使用
  std::unique_ptr<v8::ArrayBuffer::Allocator> allocator =
      ArrayBufferAllocator::Create();

  // 2. 创建 Isolate::CreateParams
  // 包含创建 Isolate 所需的所有参数
  v8::Isolate::CreateParams create_params;
  create_params.array_buffer_allocator = allocator.get();
  // ... 其他参数设置，例如快照数据

  // 3. 创建 Isolate
  v8::Isolate* isolate = v8::Isolate::New(create_params);
  if (!isolate) {
    return nullptr;
  }

  // 4. 释放 allocator 的所有权，由 Isolate 管理
  // 注意：Node.js 通常会把 allocator 绑定到 Environment 对象，并由其管理生命周期
  // 这里简化了，实际情况更复杂
  create_params.array_buffer_allocator.release();

  // 5. 设置 Isolate 的数据槽，用于存储自定义数据
  // 例如，可以将 Environment 指针存储在这里，方便在回调中获取
  // isolate->SetData(kNodeContextEmbedderDataIndex, env_ptr);

  return std::unique_ptr<v8::Isolate>(isolate);
}

v8::SetIsolateDelegate()

这个函数用于设置 V8 Isolate 的一些回调，例如当 Promise 被拒绝但没有处理时，或者当发生未捕获的异常时，V8 会通过这些回调通知宿主环境。Node.js 会利用这些回调来实现 process.on('unhandledRejection') 和 process.on('uncaughtException') 等机制。

// src/node.cc (片段)
// ...
void SetIsolateDelegate(v8::Isolate* isolate, v8::Platform* platform) {
  // 设置各种事件处理器，例如 Promise 拒绝处理、消息处理等
  isolate->SetHostInitializeImportMetaObjectCallback(
      HostInitializeImportMetaObject);
  isolate->SetHostImportModuleDynamicallyCallback(HostImportModuleDynamically);
  isolate->SetPromiseRejectCallback(PromiseRejectCallback);
  // ... 其他回调设置
}
// ...

通过这些步骤，V8 引擎就被成功初始化并准备就绪，可以开始执行 JavaScript 代码了。

Node.js 运行时环境的核心：node::Environment

node::Environment 是 Node.js 启动流程中的核心概念。它是一个 C++ 对象，封装了一个 Node.js 实例运行所需的所有状态，包括：

  • *`v8::Isolate isolate_`**：对应的 V8 实例。
  • v8::Local<v8::Context> context_：对应的 V8 JavaScript 上下文。
  • *`uv_loop_t eventloop`**：对应的 libuv 事件循环。
  • std::vector<std::string> args_：命令行参数。
  • std::vector<std::string> exec_args_：Node.js 运行时参数。
  • 各种内部模块、绑定、回调函数等。

node::CreateEnvironment() 函数负责创建并初始化这个 Environment 对象。

// src/node.cc (片段)
// ...
std::unique_ptr<Environment> CreateEnvironment(
    v8::Isolate* isolate,
    uv_loop_t* event_loop,
    const std::vector<std::string>& args,
    const std::vector<std::string>& exec_args) {

  // 1. 创建 V8 Context
  // Context 是 JavaScript 执行的“沙箱”，拥有自己的全局对象
  v8::Local<v8::Context> context =
      v8::Context::New(isolate); // 实际创建过程更复杂，可能涉及快照

  // 2. 进入 Context
  v8::Context::Scope context_scope(context);

  // 3. 创建 Environment 实例
  Environment* env = new Environment(context, isolate, event_loop, args, exec_args);

  // 4. 初始化 Environment
  // 这会设置 Isolate 的一些数据槽，以便在 JS 回调中能访问到 env
  env->Initialize();

  // 5. 将 env 存储到 Context 的内部字段中
  // 这样在 JS 代码中，可以通过 Context 访问到对应的 Environment 对象
  context->SetAlignedPointerInEmbedderData(kNodeContextEmbedderDataIndex, env);

  return std::unique_ptr<Environment>(env);
}
// ...

Environment 对象是 Node.js 运行时状态的中心枢纽。所有的 JavaScript 代码都将在其关联的 v8::Context 中执行，所有的异步操作都将通过其关联的 uv_loop_t 进行调度。

事件循环的奠基：libuv 初始化

Node.js 的非阻塞 I/O 和事件驱动模型依赖于 libuv 库。在 node::Start() 中，libuv 的事件循环 uv_loop_t 被初始化。

// src/node.cc (片段)
// ...
uv_loop_t default_loop;
int err = uv_loop_init(&default_loop); // 初始化 libuv 事件循环
if (err) {
  // 错误处理
  return 1;
}
// ...

uv_loop_init() 函数会初始化 uv_loop_t 结构体，分配必要的资源，使其准备好接收和处理事件。这个 default_loop 随后会被传递给 CreateEnvironment()，成为 node::Environment 的一部分。

libuv 事件循环是 Node.js 异步编程的基础。它负责监听文件系统事件、网络事件、定时器事件等，并在事件发生时调度相应的回调函数。

JavaScript 上下文的构建：v8::Context

v8::Context 是 V8 引擎中 JavaScript 代码执行的“沙箱”。每个 Context 都有其独立的全局对象（例如 global 或 window）、内置对象（Object、Array、Function 等）和作用域链。Node.js 在启动时会创建一个主 Context。

创建 Context 的过程在 CreateEnvironment() 内部进行。

// src/node.cc (片段)
// ...
v8::Local<v8::Context> context = v8::Context::New(isolate);
// ...

然而，v8::Context::New(isolate) 的实际创建过程比看起来要复杂。V8 引擎在创建 Context 时，需要初始化大量的内置对象和函数。为了加速这个过程，Node.js 采用了 快照（Snapshot） 机制。

快照机制

快照是 V8 引擎的一项重要优化技术。它允许将一个已经初始化好的 v8::Isolate 或 v8::Context 的内存状态序列化到一个文件中。在后续的启动中，V8 可以直接从这个快照文件反序列化出预先初始化好的 Isolate 或 Context，从而大大减少启动时间。

Node.js 在构建时就包含了预生成的 V8 快照。这个快照包含了：

  • V8 的内置对象和函数。
  • Node.js 一部分核心的 C++ 绑定。
  • Node.js 引导 JavaScript 代码的预编译字节码。

当 v8::Context::New(isolate) 被调用时，如果 Node.js 配置了使用快照，V8 会直接从快照加载 Context 的初始状态，而不是从头开始构建，这显著提升了 Node.js 的启动速度。

在 v8::Context::New 之后，Node.js 会在 Context 的全局对象上设置一些初始属性，例如 global、process 的占位符，以及 console 的基本实现等。这些操作在 C++ 层面完成，是 JavaScript 引导程序 (internal/bootstrap/node.js) 运行前的准备工作。

// src/node_context_utils.cc (简化)
// ...
void SetupContext(v8::Local<v8::Context> context, Environment* env) {
  v8::Isolate* isolate = env->isolate();
  v8::Local<v8::Object> global_object = context->Global();

  // 设置 global 对象的原型，使其包含一些 Node.js 特有的全局变量
  // v8::Local<v8::Object> global_proxy = context->Global();
  // v8::Local<v8::Object> global_private = GetPrivateGlobal(context);

  // 注入 process 对象（初始版本）
  v8::Local<v8::Object> process_obj = v8::Object::New(isolate);
  global_object->Set(context, FIXED_ONE_BYTE_STRING(isolate, "process"), process_obj).FromJust();

  // 注入 console 对象
  v8::Local<v8::Object> console_obj = v8::Object::New(isolate);
  global_object->Set(context, FIXED_ONE_BYTE_STRING(isolate, "console"), console_obj).FromJust();

  // ... 注入其他全局对象，例如 Buffer, setTimeout 等的占位符或简易实现
}

这些 C++ 级别的注入为后续 JavaScript 引导代码提供了执行的基础环境。

内置模块的加载与引导

Node.js 有大量的内置模块，其中一部分是 C++ 实现的（例如 fs, net, http 的底层），另一部分是 JavaScript 实现的（位于 lib/internal 目录）。在 Environment 创建之后，这些内置模块会被加载并暴露给 JavaScript。

node::loader::InitializeBuiltinModules() 函数负责这个过程。

// src/node.cc (片段)
// ...
loader::InitializeBuiltinModules(env.get());
// ...

InitializeBuiltinModules 的主要工作是：

  1. 注册 C++ 绑定：将 C++ 实现的模块（例如 node_buffer.cc, node_fs.cc）注册到 V8 上下文中，使其可以通过 process.binding('module_name') 在 JavaScript 中访问。这些绑定通常会导出一些函数或对象，供 JavaScript 层调用。
  2. 加载 JavaScript 内置模块：将 Node.js 自身 lib/internal 目录下的 JavaScript 文件作为字符串嵌入到 C++ 代码中，然后在 V8 上下文中编译并执行。这些模块通常是纯 JavaScript 实现的，但它们构建在 C++ 绑定之上，并提供更高级别的 API。

Node.js 使用了一个叫做 BuiltinLoader 的机制来管理这些内置模块。它将 JavaScript 内置模块的代码字符串存储在 C++ 中，并在需要时（通常是启动时）编译并执行它们。

// src/node_builtins.cc (简化示例)

// 假设有一个内部 JS 模块 'internal/per_context/setup.js'
// 它的内容在构建时被转换为 C++ 字符串字面量

namespace node {
namespace loader {

// 这是一个简化的表示，实际是一个复杂的映射和管理机制
struct BuiltinModule {
  const char* id;
  const char* source;
};

// 所有内置模块的列表
static const BuiltinModule kBuiltinModules[] = {
  {"internal/per_context/setup", "/* JavaScript code for setup */"},
  {"internal/bootstrap/node", "/* JavaScript code for bootstrap */"},
  // ... 更多内置模块
};

void InitializeBuiltinModules(Environment* env) {
  // 获取 V8 上下文
  v8::HandleScope handle_scope(env->isolate());
  v8::Local<v8::Context> context = env->context();
  v8::Context::Scope context_scope(context);

  // 1. 注册 C++ 绑定
  // 例如，注册 'buffer' 模块的 C++ 导出
  // node::Buffer::Initialize(env, context->Global());

  // 2. 加载 JavaScript 内置模块
  // 实际会通过一个 BuiltinLoader 对象来管理
  // BuiltinLoader loader(env);
  // for (const auto& module : kBuiltinModules) {
  //   loader.RegisterBuiltin(module.id, module.source);
  // }

  // 假设我们现在要执行 'internal/bootstrap/node.js'
  // loader.CompileAndRunBuiltin(env, "internal/bootstrap/node");
}

} // namespace loader
} // namespace node

通过这种方式，Node.js 核心的 JavaScript 代码在用户代码执行之前就已经准备好了。

从 C++ 到 JavaScript：node::LoadEnvironment()

这是 C++ 世界与 JavaScript 世界的正式交界点。node::LoadEnvironment() 函数的主要职责是执行 Node.js 的 JavaScript 引导代码，即 internal/bootstrap/node.js。

// src/node.cc (片段)
// ...
LoadEnvironment(env.get());
// ...

void LoadEnvironment(Environment* env) {
  v8::HandleScope handle_scope(env->isolate());
  v8::Local<v8::Context> context = env->context();
  v8::Context::Scope context_scope(context);

  // 1. 编译并执行 internal/per_context/setup.js
  // 这个脚本通常用于设置一些 V8 context 级别的全局变量和函数
  // 例如，设置 setTimeout, setInterval 等的 C++ 绑定
  loader::CompileAndRunBuiltin(env, "internal/per_context/setup");

  // 2. 编译并执行 internal/bootstrap/node.js
  // 这是 Node.js JavaScript 引导程序的核心
  loader::CompileAndRunBuiltin(env, "internal/bootstrap/node");

  // 3. 标记环境已加载
  env->set_has_loaded_bootstrappers(true);
}

internal/per_context/setup.js 是一个相对较小的脚本，主要用于设置一些特定于 V8 Context 的全局函数和对象，例如 setTimeout, setInterval，它们的底层实现通常是 C++ 绑定。

而 internal/bootstrap/node.js 则是 Node.js 启动流程中最重要的 JavaScript 文件。

JavaScript 引导程序：internal/bootstrap/node.js 的世界

internal/bootstrap/node.js 是 Node.js 运行时创建的 JavaScript 端的核心。它在 C++ 层面被加载并执行，其主要任务是：

  1. 构建 process 对象：这是 Node.js 全局 process 对象的核心，包括 argv, env, version, versions, cwd(), exit(), nextTick() 等。
  2. 填充 global 对象：将 Buffer, console, setTimeout, setInterval, clearTimeout, clearInterval 等全局 API 注入到 global 对象中。
  3. 初始化模块系统：设置 CommonJS 模块系统的 require 函数，以及 ES Modules 的加载器。
  4. 准备用户代码执行环境：设置好一切，以便后续能够加载并执行用户编写的 JavaScript 代码。

让我们看一些 internal/bootstrap/node.js 的简化片段：

// lib/internal/bootstrap/node.js (简化)

'use strict';

// 1. 获取 C++ 绑定 (假设 C++ 已经通过 'process.binding' 暴露了)
const binding = {
  // 获取 Node.js 的 C++ 内部绑定
  // 例如 process_wrap 提供了 process.nextTick 等底层实现
  // fs 提供了文件系统操作的底层实现
  process_wrap: process.binding('process_wrap'),
  // ... 其他 C++ 绑定
};

// 2. 构建 process 对象
// C++ 层面已经创建了一个空的 process 对象，这里填充其属性和方法
const _process = global.process; // 获取 C++ 注入的空 process 对象

Object.defineProperty(_process, 'argv', {
  value: binding.process_wrap.argv, // 从 C++ 获取命令行参数
  enumerable: true,
  configurable: false
});

Object.defineProperty(_process, 'env', {
  value: binding.process_wrap.env, // 从 C++ 获取环境变量
  enumerable: true,
  configurable: false
});

// ... 更多 process 属性和方法，例如 versions, arch, platform 等
// 例如 nextTick 的实现
_process.nextTick = (callback, ...args) => {
  // 实际的 nextTick 会使用 C++ 绑定来实现微任务队列
  binding.process_wrap.runMicrotasks(); // 触发 V8 的微任务队列
  queueMicrotask(() => callback(...args)); // 将回调放入微任务队列
};

// 3. 构建 console 对象
// C++ 层面已经创建了一个空的 console 对象
const _console = global.console;

_console.log = function(...args) {
  // 实际会通过 C++ 绑定调用 process.stdout.write
  binding.fs.writeSync(1, args.join(' ') + 'n');
};
// ... 其他 console 方法

// 4. 定义全局变量 (例如 Buffer)
// Buffer 是 Node.js 独有的全局类
global.Buffer = require('buffer').Buffer; // 通过 require 加载 buffer 模块

// 5. 设置定时器函数
// 这些函数在 internal/per_context/setup.js 中已经有 C++ 绑定
global.setTimeout = require('timers').setTimeout;
global.setInterval = require('timers').setInterval;
// ... clear 对应函数

// 6. 初始化模块系统
// CommonJS 模块系统
const Module = require('internal/modules/cjs/loader');
Module.setGlobalPaths(binding.process_wrap.modulePaths); // 设置 require 的查找路径

// ES Modules 加载器
const { initializeESMLoader } = require('internal/process/esm_loader');
initializeESMLoader();

// 7. 准备执行用户代码的函数
// 这通常是一个内部函数，在用户代码执行时会被调用
function startupUserScript() {
  // 获取用户脚本路径
  const script = _process.argv[1];

  if (script) {
    // 运行用户脚本 (CommonJS 或 ESM)
    if (Module.isMainThread()) { // 如果是主线程
      Module.runMain(script); // CommonJS 入口
    } else {
      // Worker Threads 或 ESM 的入口
      // ...
    }
  }
}

// 暴露 startupUserScript 给 C++ 调用
// 实际是通过一个内部机制，C++ 拿到这个函数句柄
global.startupUserScript = startupUserScript;

这个引导脚本是 Node.js 能够作为一个功能齐全的 JavaScript 运行时环境的关键。它连接了 C++ 提供的底层能力与 JavaScript 世界的高级抽象。

用户代码的执行：CommonJS 与 ES Modules

在 internal/bootstrap/node.js 执行完毕后，Node.js 已经准备好加载并运行用户编写的 JavaScript 代码了。这一步通常发生在 C++ 端的 node::LoadEnvironment() 之后，通过一个在 Environment 中注册的 JavaScript 函数句柄来触发。

CommonJS 模块

对于传统的 CommonJS 模块，Node.js 会调用 Module.runMain() 函数。

// lib/internal/modules/cjs/loader.js (简化)

// ...

// Module 构造函数
function Module(id, parent) {
  this.id = id;
  this.exports = {};
  // ...
}

// Module._load 负责加载、编译和缓存模块
Module._load = function(request, parent, isMain) {
  // 1. 解析模块路径
  const filename = Module._resolveFilename(request, parent, isMain);

  // 2. 检查缓存
  let cachedModule = Module._cache[filename];
  if (cachedModule) {
    return cachedModule.exports;
  }

  // 3. 创建新模块实例
  const module = new Module(filename, parent);
  Module._cache[filename] = module;

  // 4. 加载模块内容
  // 根据文件扩展名调用不同的加载器 (.js, .json, .node)
  module.load(filename);

  return module.exports;
};

// 运行主模块
Module.runMain = function() {
  // 获取主模块路径 (通常是 process.argv[1])
  const mainScript = process.argv[1];
  Module._load(mainScript, null, true); // 加载主模块，isMain 为 true
};

// ...

当 Module.runMain() 被调用时，它会使用 Module._load() 来加载用户指定的主模块。Module._load() 会处理模块的解析、缓存、编译和执行。对于 .js 文件，它会读取文件内容，然后将其包裹在一个函数中执行，并将 exports、require、module、__filename、__dirname 作为参数传递进去。

// 假设用户文件 app.js
// console.log("Hello from user app!");
// const os = require('os');
// console.log(os.platform());

// Node.js 实际执行时会变成类似这样：
(function(exports, require, module, __filename, __dirname) {
  console.log("Hello from user app!");
  const os = require('os');
  console.log(os.platform());
})(exports, require, module, filename, dirname);

ES Modules

对于 ES Modules，加载流程则更为复杂，它遵循 ECMAScript 规范。Node.js 内部有一个 ES Module Loader，负责解析 import 和 export 语句，进行模块图构建、实例化和求值。

internal/process/esm_loader.js 在引导阶段被初始化，它会设置 node:module 导出的 Loader 类，并处理 import 语句的解析和加载。

当 Node.js 启动时，如果入口文件被识别为 ES Module（例如，文件扩展名为 .mjs 或 package.json 中 type 字段为 "module"），则会通过 ES Module Loader 来加载。

// lib/internal/process/esm_loader.js (简化)

// ...
const { ESMLoader } = require('internal/modules/esm/loader');
const { get              // 从 C++ 绑定获取
  initializeESMLoader() {
  // 创建并初始化 ESMLoader 实例
  const loader = new ESMLoader();
  // ... 注册各种 hook，例如 resolve, load
  // 使得 Node.js 能够处理 import 语句
  // global.getBuiltinESMLoader = () => loader; // 暴露给内部使用
}
// ...

ESM 的加载过程涉及到：

  1. 解析（Parse）：将模块代码解析成抽象语法树（AST）。
  2. 加载（Load）：获取模块的源代码，以及其所有 import 声明引用的模块。
  3. 链接（Link）：将模块的 import 和 export 绑定到对应的模块。
  4. 求值（Evaluate）：执行模块代码，填充其导出的值。

这是一个异步且可能涉及网络请求的过程（例如，未来支持 HTTP 导入），但对于本地文件，Node.js 会高效地处理。

事件循环的运转与生命周期

在用户代码执行完毕后，如果应用程序还有待处理的异步任务（例如，一个 setTimeout，一个网络请求，或者一个文件读取操作），Node.js 进程并不会立即退出。相反，它会进入由 libuv 提供的事件循环。

// src/node.cc (片段)
// ...
int exit_code = uv_run(&default_loop, UV_RUN_DEFAULT);
// ...

uv_run() 是 libuv 事件循环的核心函数。它会不断地检查事件队列，并在有事件发生时执行相应的回调函数。

事件循环的典型阶段包括：

  1. Timers (定时器)：执行 setTimeout() 和 setInterval() 的回调。
  2. Pending Callbacks (待处理回调)：执行上一个循环迭代中，系统操作（如 TCP 错误）的回调。
  3. Idle, Prepare (空闲/准备)：仅在内部使用。
  4. Poll (轮询)：等待新的 I/O 事件，例如网络请求到达、文件读取完成。这是事件循环中最长的时间段。如果队列中有定时器或 I/O 回调，它会等待直到这些事件准备就绪。
  5. Check (检查)：执行 setImmediate() 的回调。
  6. Close Callbacks (关闭回调)：执行 close 事件的回调，例如 socket.on('close')。

uv_run() 的模式：

  • UV_RUN_DEFAULT：只要有活跃的句柄（handles）或请求（requests），事件循环就会持续运行。这是 Node.js 的默认模式。
  • UV_RUN_ONCE：事件循环会阻塞直到有事件发生，然后处理一个或多个事件，最后返回。
  • UV_RUN_NOWAIT：事件循环会处理所有可用的事件，但不会阻塞。

Node.js 应用程序的生命周期由 uv_run(&default_loop, UV_RUN_DEFAULT) 维持。只有当所有活跃的句柄（如打开的服务器、活动的定时器、待处理的 I/O 操作）都关闭，事件循环才会退出，进程随之终止。

性能优化：快照（Snapshot）与启动速度

在前面我们提到了快照机制在 v8::Context 创建中的应用。实际上，Node.js 对快照的使用更为广泛，它是 Node.js 快速启动的关键之一。

Node.js 在编译时会生成一个包含 V8 引擎和 Node.js 核心代码的快照。这个快照不仅仅包含 V8 的内置对象，还包含了 Node.js 核心 JavaScript 模块（例如 internal/bootstrap/node.js 及其依赖）的预编译字节码和数据。

快照带来的好处：

  1. 减少启动时间：无需在运行时重新解析和编译大量的 JavaScript 代码，直接从快照加载已经预编译好的字节码。
  2. 减少内存消耗：多个 Isolate 可以共享同一个快照的只读部分，节省内存。
  3. 一致性：确保每个 Node.js 实例都以相同的、预定义的状态启动。

当 Node.js 启动时，它会告诉 V8 使用这个内置的快照。V8 会根据快照快速地初始化 Isolate 和 Context，直接进入执行阶段，省去了繁重的初始化工作。

结束语

通过上述深入的剖析，我们已经完整地走过了 Node.js 的启动流程。从 C++ main 函数开始，我们见证了 V8 引擎的初始化、libuv 事件循环的建立、node::Environment 这一核心对象的诞生，以及 v8::Context 的精细构建。随后，我们了解了 Node.js 如何通过 C++ 绑定和 JavaScript 引导程序 (internal/bootstrap/node.js) 来构建 process、global 等全局对象，并初始化其模块系统。最终，用户编写的 JavaScript 代码被加载并执行，应用程序进入由 libuv 驱动的事件循环，等待并处理异步事件。这个复杂而高效的启动过程，是 Node.js 能够成为高性能、事件驱动的 JavaScript 运行时的基石。理解这些底层机制，无疑能帮助我们更好地驾驭 Node.js，编写出更健壮、更高效的应用。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注