通过源码分析nodejs的进程架构

我们知道nodejs是单进程（单线程）的，但是nodejs也为用户实现了多进程的能力，下面我们看一下nodejs里多进程的架构是怎么样的。
    nodejs提供同步和异步创建进程的方式。我们首先看一下异步的方式，nodejs创建进程的方式由很多种。但是归根到底是通过spawn函数。所以我们从这个函数开始，看一下整个流程。

var spawn = exports.spawn = function(/*file, args, options*/) {

  var opts = normalizeSpawnArguments.apply(null, arguments);
  var options = opts.options;
  var child = new ChildProcess();

  debug('spawn', opts.args, options);

  child.spawn({
    file: opts.file,
    args: opts.args,
    cwd: options.cwd,
    windowsHide: !!options.windowsHide,
    windowsVerbatimArguments: !!options.windowsVerbatimArguments,
    detached: !!options.detached,
    envPairs: opts.envPairs,
    stdio: options.stdio,
    uid: options.uid,
    gid: options.gid
  });

  return child;
};

我们看到spawn函数只是对ChildProcess函数的封装。然后调用他的spawn函数（只列出核心代码）。

const { Process } = process.binding('process_wrap');

function ChildProcess() {
  EventEmitter.call(this);
  this._handle = new Process();
}

ChildProcess.prototype.spawn = function(options) {
	this._handle.spawn(options);
}

ChildProcess也是对Process的封装。Process是js层和c++层的桥梁，我们找到他对应的c++模块。

NODE_BUILTIN_MODULE_CONTEXT_AWARE(process_wrap, node::ProcessWrap::Initialize)

即在js层调用process.binding(‘process_wrap’)的时候，拿到的是node::ProcessWrap::Initialize导出的对象。

  static void Initialize(Local<Object> target,
                         Local<Value> unused,
                         Local<Context> context
  ) {
    Environment* env = Environment::GetCurrent(context);
    // 定义一个构造函数，值是New
    Local<FunctionTemplate> constructor = env->NewFunctionTemplate(New);
    constructor->InstanceTemplate()->SetInternalFieldCount(1);
    //  拿到一个字符串
    Local<String> processString =
        FIXED_ONE_BYTE_STRING(env->isolate(), "Process");
    constructor->SetClassName(processString);

    AsyncWrap::AddWrapMethods(env, constructor);
	// 设置这个构造函数的原型方法
    env->SetProtoMethod(constructor, "close", HandleWrap::Close);

    env->SetProtoMethod(constructor, "spawn", Spawn);
    env->SetProtoMethod(constructor, "kill", Kill);
	...
	/*
		类似js里的module.exports = {Process: New}
		js层new Process的时候会相对于执行new New
	*/
    target->Set(processString, constructor->GetFunction());
  }

上面的代码翻译成js大概如下。

function New() {}
New.prototype = {
	spawn: Spawn,
	kill: Kill,
	close: Close
	...
}
module.exports = {Process: New}

所以new Process的时候，执行的是new New。

static void New(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   new ProcessWrap(env, args.This());
}

 ProcessWrap(Environment* env, Local<Object> object)
     : HandleWrap(
		   env,
           object,
           reinterpret_cast<uv_handle_t*>(&process_),
           AsyncWrap::PROVIDER_PROCESSWRAP
	) 
{
}

我们看到new New就是new ProcessWrap，但是New函数没有返回一个值。继续往下看。

HandleWrap::HandleWrap(...) {
  Wrap(object, this);
}

void Wrap(v8::Local<v8::Object> object, TypeName* pointer) {
  object->SetAlignedPointerInInternalField(0, pointer);
}

v8的套路有点复杂，大致就是在FunctionCallbackInfo对象里保存了ProcessWrap类的对象。后续调用的时候会取出来。然后给js返回一个对象。接着

this._handle.spawn(options);

这时候会执行

  static void Spawn(const FunctionCallbackInfo<Value>& args) {
    Environment* env = Environment::GetCurrent(args);
    Local<Context> context = env->context();
    ProcessWrap* wrap;
    /*
    	取出刚才的ProcessWrap对象
		wrap = args->GetAlignedPointerFromInternalField(0);
	*/
    ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());

    int err = uv_spawn(env->event_loop(), &wrap->process_, &options);

    args.GetReturnValue().Set(err);
  }

接着我们通过uv_spawn来到了c语言层。uv_spawn总的来说做了下面几个事情。
1 主进程注册SIGCHLD信号，处理函数为uv__chld。SIGCHLD信号是子进程退出时发出的。
2 处理进程间通信、标准输入、输出。
3 fork出子进程
4 在uv_process_t结构图中保存子进程信息，uv_process_t是c++层和c层的联系。
5 把uv_process_t插入libuv事件循环的process_handles队列
6 主进程和子进程各自运行。
整个流程下来，大致形成如图所示的架构。

当进程退出的时候。nodejs主进程会收到SIGCHLD信号。然后执行uv__chld。该函数遍历libuv进程队列中的节点，通过waitpid判断该节点对应的进程是否已经退出后，从而收集已退出的节点，然后移出libuv队列，最后执行已退出进程的回调。

static void uv__chld(uv_signal_t* handle, int signum) {
  uv_process_t* process;
  uv_loop_t* loop;
  int exit_status;
  int term_signal;
  int status;
  pid_t pid;
  QUEUE pending;
  QUEUE* q;
  QUEUE* h;
  // 保存进程（已退出的状态）的队列
  QUEUE_INIT(&pending);
  loop = handle->loop;

  h = &loop->process_handles;
  q = QUEUE_HEAD(h);
  //  收集已退出的进程
  while (q != h) {
    process = QUEUE_DATA(q, uv_process_t, queue);
    q = QUEUE_NEXT(q);

    do
      // WNOHANG非阻塞等待子进程退出，其实就是看哪个子进程退出了，没有的话就直接返回，而不是阻塞 
      pid = waitpid(process->pid, &status, WNOHANG);
    while (pid == -1 && errno == EINTR);
   
    if (pid == 0)
      continue;
    // 进程退出了，保存退出状态，移出队列，插入peding队列，等待处理
    process->status = status;
    QUEUE_REMOVE(&process->queue);
    QUEUE_INSERT_TAIL(&pending, &process->queue);
  }

  h = &pending;
  q = QUEUE_HEAD(h);
  // 是否有退出的进程
  while (q != h) {
    process = QUEUE_DATA(q, uv_process_t, queue);
    q = QUEUE_NEXT(q);
    QUEUE_REMOVE(&process->queue);
    QUEUE_INIT(&process->queue);
    uv__handle_stop(process);

    if (process->exit_cb == NULL)
      continue;

    exit_status = 0;
    // 获取退出信息，执行上传回调
    if (WIFEXITED(process->status))
      exit_status = WEXITSTATUS(process->status);

    term_signal = 0;
    if (WIFSIGNALED(process->status))
      term_signal = WTERMSIG(process->status);

    process->exit_cb(process, exit_status, term_signal);
  }
}

这就是nodejs中进程的整个生命周期。
    接下来看看如何以同步的方式创建进程。入口函数是spawnSync。对应的c++模块是spawn_sync。过程就不详细说明了，直接看核心代码。

void SyncProcessRunner::TryInitializeAndRunLoop(Local<Value> options) {
  int r;

  uv_loop_ = new uv_loop_t;
 // ExitCallback会把子进程的结构体从libuv中移除
  uv_process_options_.exit_cb = ExitCallback;
  r = uv_spawn(uv_loop_, &uv_process_, &uv_process_options_);
  r = uv_run(uv_loop_, UV_RUN_DEFAULT);
}

我们看到，对于同步创建进程，nodejs没有使用waitpid这种方式阻塞自己，从而等待子进程退出。而是重新开启了一个事件循环。我们知道uv_run是一个死循环，所以这时候，nodejs主进程会阻塞在上面的uv_run。直到子进程退出，uv_run才会退出循环，从而再次回到nodejs原来的事件循环。