深入出不来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，取出一个，删除并触发。
下面用一个图来总结一下：
完结撒花！