深入出不来nodejs源码-timer模块(C++篇)

　　终于可以填上坑了。

　　简单回顾一下之前js篇内容，每一次settimeout的调用，会在一个对象中添加一个键值对，键为延迟时间，值为一个链表，将所有该时间对应的事件串起来，图如下：

　　而每一个延迟键值对的触发，则是在链表头生成的时候就已经开始了，如下：

function timerslist(msecs, unrefed) {
  //...

  // 来源于c++内置模块
  const timer = this._timer = new timerwrap();
  /// ...
  
  // 触发
  timer.start(msecs);
}

　　回顾完毕。

 

　　与js篇一样，这一节也简单介绍libuv内部的一个数据结构：二叉树。源码来源于：uv/src/heap-inl.h。

　　因为二叉树的介绍网上一堆，所以这里只看一下api，首先是节点：

struct heap_node {
  struct heap_node* left;
  struct heap_node* right;
  struct heap_node* parent;
};

　　分别代表左右、父节点。

/* a binary min heap.  the usual properties hold: the root is the lowest
 * element in the set, the height of the tree is at most log2(nodes) and
 * it's always a complete binary tree.
 *
 * the heap function try hard to detect corrupted tree nodes at the cost
 * of a minor reduction in performance.  compile with -dndebug to disable.
 */
struct heap {
  struct heap_node* min;
  unsigned int nelts;
};

　　这里的注释可以看一下，这个结构体是独立的，min指向当前树的最小值。

　　另外还有三个操作方法：

heap_export(void heap_insert(struct heap* heap,
                             struct heap_node* newnode,
                             heap_compare_fn less_than));
heap_export(void heap_remove(struct heap* heap,
                             struct heap_node* node,
                             heap_compare_fn less_than));
heap_export(void heap_dequeue(struct heap* heap, heap_compare_fn less_than));

　　分别代表树的插入、移除，以及将小于指定值的节点移除并重新整理树，实现自己去看，懒得讲。

 

　　进入正题，从js的触发代码开始看。

　　废话不多说，直接进入timer_wrapper.cc看start方法，源码如下：

static void start(const functioncallbackinfo<value>& args) {
  // 不管这3行
  timerwrap* wrap;
  assign_or_return_unwrap(&wrap, args.holder());

  check(handlewrap::isalive(wrap));
  // 这个args就是js函数参数的包装 可以理解成数组
  int64_t timeout = args[0]->integervalue();
  // libuv的方法 第三个参数代表延迟时间
  int err = uv_timer_start(&wrap->handle_, ontimeout, timeout, 0);
  // 设置该函数返回值
  args.getreturnvalue().set(err);
}

　　可以看到，这里涉及到了libuv，继续深入，看该方法：

/*
    handle => 时间模块对象
    cb => 延迟回调函数
    timeout => 延迟时间
    repeat => 区分interval/settimeout
*/
int uv_timer_start(uv_timer_t* handle,
    uv_timer_cb cb,
    uint64_t timeout,
    uint64_t repeat) {
    uint64_t clamped_timeout;

    if (cb == null)
        return uv_einval;

    if (uv__is_active(handle))
        uv_timer_stop(handle);
    // 当前时间戳加上延迟的时间 也就是回调函数触发的时间戳
    clamped_timeout = handle->loop->time + timeout;
    if (clamped_timeout < timeout)
        clamped_timeout = (uint64_t)-1;

    // 对象赋值
    handle->timer_cb = cb;
    handle->timeout = clamped_timeout;
    handle->repeat = repeat;
    /* start_id is the second index to be compared in uv__timer_cmp() */
    handle->start_id = handle->loop->timer_counter++;
    // 注意这里，用了insert方法将对应的handle对象插入到了树中
    heap_insert(timer_heap(handle->loop),
        (struct heap_node*) &handle->heap_node,
        timer_less_than);
    uv__handle_start(handle);

    return 0;
}

　　简单说明一下，首先第一个参数可以直接当成个空对象，在一开始是啥都没有的。

　　然后是clamped_timeout，在上一节中讲过，libuv内部获取的是一个相对时间，所以这里用当前轮询的时间点加上延迟时间，得到的就是理论上的触发时间点。

　　而timer_cb就很好理解了，对应的是回调函数。

　　repeat这个值，如果是setinterval，那么值为interval的间隔时间，settimeout就是0，表示是否循环触发。

　　最后将这几个值都挂载到handle上面，通过insert方法插入这一节一开始讲的树上。

 

　　至此，一个settimeout方法所完成的操作已经讲完了。

　　显然我又错了，这个start并没有触发什么东西，最终只是把一个对象加到一个树结构上，那么又是在哪里触发的延迟调用呢？

　　答案就在uv_run中，因为偷懒，所以之前没有贴完整代码，在每一轮的事件轮询中，有两个首要操作，如下：

int uv_run(uv_loop_t *loop, uv_run_mode mode) {
    // ...略

    while (r != 0 && loop->stop_flag == 0) {
        // 上一节的更新时间
        uv_update_time(loop);
        // 这一节的内容
        uv__run_timers(loop);

        // ...
    }
}

　　第一个就是上一节讲的更新时间，第二个就涉及到延迟触发了，进入源码看一下：

void uv__run_timers(uv_loop_t* loop) {
    struct heap_node* heap_node;
    uv_timer_t* handle;

    // 死循环 保证触发所有应该触发的延迟事件
    for (;;) {
        // 该方法返回延迟事件树中最小的时间点
        heap_node = heap_min(timer_heap(loop));
        // 代表没有延迟事件
        if (heap_node == null)
            break;
        // 取出handle
        handle = container_of(heap_node, uv_timer_t, heap_node);
        // 比较handle的时间点与当前的时间点
        if (handle->timeout > loop->time)
            break;
        // 移除当前的handle
        uv_timer_stop(handle);
        // 如果是interval 需要重新插入一个新的handle到树中
        uv_timer_again(handle);
        // 触发延迟事件
        handle->timer_cb(handle);
    }
}

　　这里就把上面的树与事件轮询链接起来了，每一次轮询，首先触发的就是延迟事件，触发的方式就是去树里面找，有没有比当前时间点小的handle，取出一个，删除并触发。

　　下面用一个图来总结一下：

　　完结撒花！