Node.js之异步那些事

Node.js之异步那些事_第1张图片
nodejs

Node.js® is a JavaScript runtime built on Chrome's V8 JavaScript engine. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient.

Node.js官网上的介绍,其中事件驱动非阻塞I/O模型是被大家所津津乐道的,但是有多少人真正了解其究竟呢?有人可能会想到libuv,没错,libuv确实是其幕后英雄。那么问题又来了,到底是怎么用libuv实现的呢?下面我们来一探究竟。

Node.js之异步那些事_第2张图片
libuv

libuv当初主要就是为Node.js开发的,提供跨平台的事件驱动异步I/O能力,当然现在肯定不仅限于Node.js使用。我们先来看一下libuv的Design overview。

Node.js之异步那些事_第3张图片
architecture

从架构图上看,libuv是对多个平台上的事件驱动异步I/O库进行了封装,如Linux下的epoll、FreeBSD下的kqueue、Solaris下的event ports、Windows下的IOCP。

Node.js之异步那些事_第4张图片
loop_iteration

上图所描述的事件循环是libuv中最重要的概念,其中的Poll for I/O就是事件驱动异步I/O能力的核心。到这里我们有必要先了解一些基础知识,Linux IO模式及 select、poll、epoll详解,否则后面的东西就不是特别好理解了。

正题


经过前面的学习,应该对libuv有了一个整体的印象,总结一下, libuv其实就是把各种handleio_watcher放到事件循环里,然后每一次循环都去检查一下是否有他们关心的事件需要处理,有则调用相应的callback,没有则继续循环。要想弄清楚Node.js之异步那些事,我们需要关心的是,Node.js如何运行事件循环,何时把handleio_watcher放入事件循环,以及如何调用相应的callback

开始之前,本次分析的代码版本为Node.js v0.12.6,Linux平台。

Run

node.ccStart方法运行事件循环,精华部分如下。唯一有些特别的地方就是,在一个while循环中包了两个uv_run,模式分别是UV_RUN_ONCEUV_RUN_NOWAIT,其原因在中间的两行注释中已经说得很明白了。

...
    bool more;
    do {
      more = uv_run(env->event_loop(), UV_RUN_ONCE);
      if (more == false) {
        EmitBeforeExit(env);

        // Emit `beforeExit` if the loop became alive either after emitting
        // event, or after running some callbacks.
        more = uv_loop_alive(env->event_loop());
        if (uv_run(env->event_loop(), UV_RUN_NOWAIT) != 0)
          more = true;
      }
    } while (more == true);
...

然后我们可以看看core.cuv_run方法的代码,跟上面事件循环的流程图是可以一一对应的。

Data Structure

继续看代码之前,有必要先了解一下重要的数据结构和相互的关系,以便更好的理解。

Node.js之异步那些事_第5张图片
Data Structure

io_watcher

接着我之前文章Node.js之HelloWorld背后的大坑的思路,还拿Hello World举例子,跟libuv有关的代码都在tcp_warp.cc里面了。

  • TCPWrap::New
Node.js之异步那些事_第6张图片
New

stream.cuv__stream_init方法有如下代码,将io_watchercb设置为uv__stream_iofd设置为-1,这里只是在stream层面做的初始化设置,后面到tcp层面还会有相应的改变。

  uv__io_init(&stream->io_watcher, uv__stream_io, -1);
  • TCPWrap::Bind
Node.js之异步那些事_第7张图片
Bind

tcp.cmaybe_new_socket方法中,uv__socket方法生成了新的fduv__stream_open方法将其设置到io_watcherfd

  • TCPWrap::Listen
Node.js之异步那些事_第8张图片
Listen

tcp.cuv_tcp_listen方法中有如下代码,将io_watchercb设置为uv__server_iouv__server_io里面会调用connection_cbconnection_cb已经被设置为cb,而这个cb正是tcp_wrap.cc中的TCPWrap::OnConnection方法。

...
  tcp->connection_cb = cb;

  /* Start listening for connections. */
  tcp->io_watcher.cb = uv__server_io;
  uv__io_start(tcp->loop, &tcp->io_watcher, UV__POLLIN);
...

core.cuv__io_start方法有如下代码,利用void* watcher_queue[2]变量将io_watcher加入到uv_loop_t的队列中去,具体操作详见queue.h。将uv_loop_tuv__io_t** watchers当做数组使用,fd为下标,io_watcher为对应的值。

...

  if (QUEUE_EMPTY(&w->watcher_queue))
    QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);

  if (loop->watchers[w->fd] == NULL) {
    loop->watchers[w->fd] = w;
    loop->nfds++;
  }
...

uv__io_poll

linux-core.c中的uv__io_poll方法,一行一行的读就可以了,前面的铺垫已经做得很充分了,只要读懂谜底便可揭晓。

未完


  • 接下来我们来说说process.nextTick(callback)的事,在node.js中定义如下,把callback放到了nextTickQueue队列中,那么Node.js是在什么时候消费这个队列的呢?
    function nextTick(callback) {
      // on the way out, don't bother. it won't get fired anyway.
      if (process._exiting)
        return;

      var obj = {
        callback: callback,
        domain: process.domain || null
      };

      nextTickQueue.push(obj);
      tickInfo[kLength]++;
    }
  • tcp_wrap.ccTCPWrap::OnConnection方法有如下代码,MakeCallback方法的出处如下图。
  tcp_wrap->MakeCallback(env->onconnection_string(), ARRAY_SIZE(argv), argv);
Node.js之异步那些事_第9张图片
MakeCallback
  • async-wrap.ccMakeCallback方法有如下代码。
  env()->tick_callback_function()->Call(process, 0, NULL);
  • node.ccSetupNextTick方法有如下代码,对tick_callback_function()进行了设定。
  env->set_tick_callback_function(args[1].As());
  • node.ccSetupProcessObject方法有如下代码,SetupNextTick被设定为process中的_setupNextTick方法。
  NODE_SET_METHOD(process, "_setupNextTick", SetupNextTick);
  • node.jsstartup.processNextTick方法有如下代码。
  process._setupNextTick(tickInfo, _tickCallback, _runMicrotasks);
  • node.js_tickCallback方法代码如下,消费nextTickQueue队列中的callback方法。
    function _tickCallback() {
      var callback, threw, tock;

      scheduleMicrotasks();

      while (tickInfo[kIndex] < tickInfo[kLength]) {
        tock = nextTickQueue[tickInfo[kIndex]++];
        callback = tock.callback;
        threw = true;
        try {
          callback();
          threw = false;
        } finally {
          if (threw)
            tickDone();
        }
        if (1e4 < tickInfo[kIndex])
          tickDone();
      }

      tickDone();
    }

省略去中间步骤,实际上是产生了如下的调用关系。

TCPWrap::OnConnection()
↓↓↓
_tickCallback()

总结


简单说,整个过程是这样的,事件循环中有相应I/O事件发生的时候,libuv调用Node.js C++部分的回调,C++部分调用JavaScript部分的回调,顺便调用nextTick设定的回调。

还是认真读代码吧,以上写的仅供参考。

你可能感兴趣的:(Node.js之异步那些事)