title: Node.js 源码分析 - 从 main 函数开始
date: 2018-11-27 21:30:15
tags:
- Node.js
- Node.js 源码分析
- 源码分析
categories:
- Node.js 源码分析
此文最初于四年前发布在个人站上的,现迁移至此重发,原链接: https://laogen.site/nodejs/nodejs-src/the-main/
《Node.js 源码分析》 系列目录页:https://laogen.site/nodejs/nodejs-src/index/
知道程序大概执行逻辑,关键点执行的顺序
我们平时在终端敲下 node app.js
后,发生了什么。
具体点,知道 node.js 原生(C++)模块什么时候加载的,在哪加载的;
知道我们的 js 代码是在哪个环节被加载执行的;
知道进程的主循环(事件循环)什么时候启动的;
有了这个小目标的基础,在接下来的文章中,我们再进一步的探索 node.js 原生模块的注册是怎么实现的,怎么获取 & 初始化的,怎么曝露给 js 环境调用的;再细说 node.js 的模块机制,我们通常的 app.js
怎么被执行的;
限于篇幅,本文只先把大体执行流程捋出来,后面再开文一块块的捋。
原代码太长,先把不影响我们分析的无关代码去掉,贴上来有关整体执行逻辑的代码,代码中的 // ...
注释意思是这个地方有被省略的代码。
每段代码第一行的注释都会指出源文件位置,一些代码讲解会在代码段中的注释中进行;
本文不再介绍 V8 和 Libuv 的知识,会开专门的分类写 V8 和 Libuv,参考 {% post_link nodejs/nodejs-src/index Node.js 源码分析 - 前言 %}
/* src/node_main.cc:93 */ int main(int argc, char* argv[]) { // ... return node::Start(argc, argv); }
main函数
在 src/node_main.cc
这个文件中,这个文件主要就是存放 main函数
。
很简单,只是调用了 node::Start()
,这个函数在 src/node.cc
这个文件中,接下来的核心代码都在这个文件中。
/* src/node.cc:3011 */ int Start(int argc, char** argv) { // ... std::vector<std::string> args(argv, argv + argc); std::vector<std::string> exec_args; // This needs to run *before* V8::Initialize(). Init(&args, &exec_args); // ... v8_platform.Initialize(per_process_opts->v8_thread_pool_size); V8::Initialize(); // ... const int exit_code = Start(uv_default_loop(), args, exec_args); v8_platform.StopTracingAgent(); v8_initialized = false; V8::Dispose(); v8_platform.Dispose(); return exit_code; }
在这段代码,首先进行 V8 的初始化,然后调用了另外一个 Start(uv_loop_t*, ...)
函数,最后释放资源,进程结束;
其中值得注意的一点,在初始化 V8 之前,调用了一个 Init()
函数,这个函数主要完成了 Node.js 原生(C++)模块的注册,就是 fs
http
等模块的 C++ 实现模块。
/* src/node.cc:2559 */ void Init(std::vector<std::string>* argv, std::vector<std::string>* exec_argv) { // ... // Register built-in modules RegisterBuiltinModules(); // ... }
Init()
中调用了 RegisterBuiltinModules()
,它注册了所有 Node.js 原生模块,关于原生模块的注册,本文不再继续跟进去,下一篇会单独展开这一块,这里先知道这个流程。
记住这个
RegisterBuiltinModules()
,下一篇文章就从这里开始展开。
/* src/node.cc:2964 */ inline int Start(uv_loop_t* event_loop, const std::vector<std::string>& args, const std::vector<std::string>& exec_args) { std::unique_ptr<ArrayBufferAllocator, decltype(&FreeArrayBufferAllocator)> allocator(CreateArrayBufferAllocator(), &FreeArrayBufferAllocator); // 创建 Isolate 实例 Isolate* const isolate = NewIsolate(allocator.get()); // ... int exit_code; { Locker locker(isolate); Isolate::Scope isolate_scope(isolate); HandleScope handle_scope(isolate); // ... exit_code = Start(isolate, isolate_data.get(), args, exec_args); } // ... isolate->Dispose(); return exit_code; }
这个 Start()
倒也没做什么,主要工作是创建了 Isolate 实例,然后调用了另外一个 Start(Isolate*...)
。
/* src/node.cc:2868 */ inline int Start(Isolate* isolate, IsolateData* isolate_data, const std::vector<std::string>& args, const std::vector<std::string>& exec_args) { HandleScope handle_scope(isolate); // 创建 V8 Context 对象 Local<Context> context = NewContext(isolate); Context::Scope context_scope(context); // 创建 Environment 对象,这个是 Node.js 的类 Environment env(isolate_data, context, v8_platform.GetTracingAgentWriter()); // 这里面主要完成 libuv 的初始化,以及创建 process 对象 // 就是 Node.js 中那个全局的 process 对象,这里不细展开 env.Start(args, exec_args, v8_is_profiling); { // ... // LoadEnvironment 是本文重要的关键点 LoadEnvironment(&env); env.async_hooks()->pop_async_id(1); } // 下面就是进程的主循环 { // ... bool more; // ... do { uv_run(env.event_loop(), UV_RUN_DEFAULT); // ... more = uv_loop_alive(env.event_loop()); if (more) continue; // ... } while (more == true); } // ... return exit_code; }
这段代码创建并使用了 js 执行需要的 context,然后创建了 Environment
对象;
这个 Environment
对象是 Node.js 源码中重要的一个对象,它是一个全局单例,定义和存储了一些重要的全局对象和函数,比如刚开始创建的 Isolate 对象、刚刚创建的 Context 对象等,注意它不是 V8 的,是 Node.js 定义的,对它的使用贯穿整个 Node.js 执行的生命周期。
再下面是进程的主循环,uv_run()
启动了 Libuv
的事件循环, 它也是 Node.js 进程的主循环,Libuv
会单独写文介绍。
最后说一下,中间的 LoadEnvironment()
调用,它是在程序进入主循环之前最关键的一环;
LoadEnvironment()
完成了一些 js 文件的加载和执行,其中就包括加载执行通常编写的 app.js
。
/* src/node.cc:2115 */ void LoadEnvironment(Environment* env) { HandleScope handle_scope(env->isolate()); // ... // The bootstrapper scripts are lib/internal/bootstrap/loaders.js and // lib/internal/bootstrap/node.js, each included as a static C string // defined in node_javascript.h, generated in node_javascript.cc by // node_js2c. // 加载两个重要的 js 文件:internal/bootstrap/loaders.js // 和 internal/bootstrap/node.js Local<String> loaders_name = FIXED_ONE_BYTE_STRING(env->isolate(), "internal/bootstrap/loaders.js"); MaybeLocal<Function> loaders_bootstrapper = GetBootstrapper(env, LoadersBootstrapperSource(env), loaders_name); Local<String> node_name = FIXED_ONE_BYTE_STRING(env->isolate(), "internal/bootstrap/node.js"); MaybeLocal<Function> node_bootstrapper = GetBootstrapper(env, NodeBootstrapperSource(env), node_name); // ... // Add a reference to the global object Local<Object> global = env->context()->Global(); env->SetMethod(env->process_object(), "_rawDebug", RawDebug); // Expose the global object as a property on itself // (Allows you to set stuff on `global` from anywhere in JavaScript.) global->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "global"), global); // 准备 binding 函数,下面调用 js 会作为参数传给 js 环境 // Create binding loaders Local<Function> get_binding_fn = env->NewFunctionTemplate(GetBinding)->GetFunction(env->context()) .ToLocalChecked(); Local<Function> get_linked_binding_fn = env->NewFunctionTemplate(GetLinkedBinding)->GetFunction(env->context()) .ToLocalChecked(); Local<Function> get_internal_binding_fn = env->NewFunctionTemplate(GetInternalBinding)->GetFunction(env->context()) .ToLocalChecked(); // 准备执行 internal/bootstrap/loaders.js 文件的参数 Local<Value> loaders_bootstrapper_args[] = { env->process_object(), get_binding_fn, get_linked_binding_fn, get_internal_binding_fn, Boolean::New(env->isolate(), env->options()->debug_options->break_node_first_line) }; // 执行 internal/bootstrap/loaders.js // Bootstrap internal loaders // 这个对象是用来接收执行结果的,记住是 bootstrapped_loaders,下面会用到 Local<Value> bootstrapped_loaders; if (!ExecuteBootstrapper(env, loaders_bootstrapper.ToLocalChecked(), arraysize(loaders_bootstrapper_args), loaders_bootstrapper_args, &bootstrapped_loaders)) { return; } // 准备执行 internal/bootstrap/node.js 的参数 // Bootstrap Node.js Local<Object> bootstrapper = Object::New(env->isolate()); SetupBootstrapObject(env, bootstrapper); Local<Value> bootstrapped_node; Local<Value> node_bootstrapper_args[] = { env->process_object(), bootstrapper, // 注意,这里是上面执行 loaders.js 返回的结果对象, // 作为执行参数传给 internal/bootstrap/node.js bootstrapped_loaders }; // 执行 internal/bootstrap/node.js if (!ExecuteBootstrapper(env, node_bootstrapper.ToLocalChecked(), arraysize(node_bootstrapper_args), node_bootstrapper_args, &bootstrapped_node)) { return; } }
LoadEnvironment()
首先加载了两个 js 文件,这两个 js 文件的位置分别在:lib/internal/bootstrap/loaders.js
和 lib/internal/bootstrap/node.js
。
我们 Node.js 开发者写的 app.js
其实就是在这两个 js 文件中加载并执行的,这块是最重要的逻辑之一,内容也很多,后面的文章会详细展开。
LoadEnvironment()
接下来创建了三个 binding 函数:
get_binding_fn
get_linked_binding_fn
get_internal_binding_fn
这3个 binding 函数是用来获取和加载 Node.js 原生模块的,会传入到 js 执行环境中,也就是你在 js 代码中是可以调用的,比如 process.binding('fs')
,在我们用 C++ 开发 Node.js 扩展模块的时候,也会用到,以后会详细展开。
LoadEnvironment()
接下来要执行 lib/internal/bootstrap/loaders.js
,在这个 js 文件中主要定义了内部(internal)模块加载器(loaders)。
lib/internal/bootstrap/loaders.js
定义的模块加载器(loaders) 接下来做为执行参数,传入了 lib/internal/bootstrap/node.js
,在 lib/internal/bootstrap/node.js
中会使用这些 loaders 来加载 internal 模块。
lib/internal/bootstrap/node.js
做了很多工作,这里只需要知道,它最终加载并执行了我们 Node.js 程序员编写的 app.js
就可以了。
到此为止,我们就知道了在命令行敲下 node app.js
大概发生了哪些事!
这只是个大概逻辑,可以配合 Node.js 源码,再花时间捋一捋,光靠贴的这点代码,可能还是会迷糊的。
接下来的文章,就是对这个执行逻辑中的关键点分别展开。
作者水平有限,写的也仓促,有误之处还请指出。
Maslow (wangfugen@126.com), laf.js 作者。