详解Nodejs的timers模块

var Timer = process.binding('timer_wrap').Timer; 
console.log(Timer); 

{ 
 [Function: Timer] 
 // Timer构造函数，可以进行实例化 
 kOnTimeout: 0, 
 // 静态属性，公用，更改会影响其他的调用 
 now: [Function: now] 
 // 静态方法，获取类似时间戳的一个数字 
} 

var Timer = process.binding('timer_wrap').Timer, 
 timer = new Timer(), 
 i = ""; 
 
console.log("obj has attribute:"); 
console.log(timer); 
 
console.log("prototype method and attribute:"); 
for(i in timer){ 
 console.log(i+"="+timer[i]); 
} 

obj has attribute: 
{} 
 
prototype method and attribute: 
close=function close() { [native code] } 
ref=function ref() { [native code] } 
unref=function unref() { [native code] } 
start=function start() { [native code] } 
stop=function stop() { [native code] } 
setRepeat=function setRepeat() { [native code] } 
getRepeat=function getRepeat() { [native code] } 
again=function again() { [native code] } 

var Timeout = function(after) { 
 // 定义内部属性，过时时间 
 this._idleTimeout = after; 
 
 // 循环链表中的两个属性，可以参考前篇文章linklist私有模块 
 this._idlePrev = this; 
 this._idleNext = this; 
 
 // 记录开始计时时间的属性 
 this._idleStart = null; 
 
 // 当时间到了，执行的回调函数 
 this._onTimeout = null; 
 
 // 该计时器，是否需要repeat，setInterval方法，该属性为true 
 this._repeat = false; 
}; 
 
 
function unrefdHandle() { 
 // unref方法的回调函数，内部this指向Timeout._handle属性 
 // 在该属性上，定义了owner属性，保存Timeout的实例化后的对象 
 this.owner._onTimeout(); 
 if (!this.owner._repeat) 
  this.owner.close(); 
} 
 
Timeout.prototype.unref = function() { 
 // 这个方法，是用来暂停计时器的 
 // 添加一个新的属性_handle用来对接C++提供的API接口 
 if (!this._handle) { 
  // 做一些初始的判断属性，设置初始值等 
  var now = Timer.now(); 
  if (!this._idleStart) this._idleStart = now; 
  var delay = this._idleStart + this._idleTimeout - now; 
  if (delay < 0) delay = 0; 
 
  // 把this指向的计时器对象，清理掉，从计时器链表中清理掉 
  exports.unenroll(this); 
 
  // 介入C++提供的API方法 
  this._handle = new Timer(); 
 
  // 添加一些属性，用来保存一些信息 
  this._handle.owner = this; 
  this._handle[kOnTimeout] = unrefdHandle; 
 
  // 开始计时，在delay后执行改方法的回调 
  this._handle.start(delay, 0); 
  this._handle.domain = this.domain; 
 
  // 调用C++提供的方法，停止计时器的执行 
  this._handle.unref(); 
 } else { 
  // 如果之前有_handle属性，那么则直接停止 
  this._handle.unref(); 
 } 
}; 
 
Timeout.prototype.ref = function() { 
 // 该方法，只有在unref之后，才起作用，恢复计时器的工作 
 // 如果在unref中，生成了_handle属性，那么使用该属性 
 // 调用C++提供的API，ref，恢复计时器的运行 
 if (this._handle) 
  this._handle.ref(); 
}; 
 
Timeout.prototype.close = function() { 
 // 当要关闭计时器对象时，如果定义过接入C++饿API的方法时 
 // 直接使用C++的方法，关闭 
 // 否则，把该方法，清理出去 
 // 不让它再lists链表中，那么当计时器执行到时，也不会执行该计时器的回调函数 
 this._onTimeout = null; 
 if (this._handle) { 
  this._handle[kOnTimeout] = null; 
  // 调用C++中提供的close方法，见前面构造函数Timer的原型链方法中 
  this._handle.close(); 
 } else { 
  exports.unenroll(this); 
 } 
}; 

'use strict'; 
 
// timer_wrap模块，为底层C++实现的模块 
var Timer = process.binding('timer_wrap').Timer; 
 // Timer在控制台打印出的数据如下： 
 // {[Function: Timer] 是一个构造函数 
 //  kOnTimeout: 0, 
 //  now: [Function: now] 
 // } 
 
// Nodejs模拟的双向链表的操作模块，请查看前一篇关于linklist的文章 
var L = require('_linklist'); 
 
// 断言的管理模块中的ok方法 
var assert = require('assert').ok; 
 
var kOnTimeout = Timer.kOnTimeout | 0; 
 
// Timeout values > TIMEOUT_MAX are set to 1. 
var TIMEOUT_MAX = 2147483647; // 2^31-1 
 
// 把timer添加到debug的模块中，并生成一个函数，命名为debug 
// 在之后，直接调用，该函数，即可把官员timer的错误信息，打印到控制台 
var util = require('util'); 
var debug = util.debuglog('timer'); 
// 注，debuglog方法，应该是最近的版本中，新添加的，因为在一年前，刚接触nodejs时， 
// util模块中，还没有该方法 
 
 
// Object containing all lists, timers 
// key = time in milliseconds 
// value = list 
var lists = {}; 
 
// the main function - creates lists on demand and the watchers associated 
// with them. 
// 把item存入到一个链表中去，并且把msecs对应的链表，存入到lists对象中去 
// lists的格式是这样的： 
 // { 
 // "1000": 这里是一个循环链表，该链表内，包含了所有msecs＝1000的list对象 
 // "2000":{} 
 // } 
 
function insert(item, msecs) { 
 // 给item定义两个私有属性 
 // 一个记录当前时间 
 item._idleStart = Timer.now(); 
 // 一个记录毫秒时间，类似于过期时间 
 item._idleTimeout = msecs; 
 
 // 如果定义的毫秒，是负值，则直接返回，不做后面的处理 
 if (msecs < 0) return; 
 
 var list; 
 
 // 如果该过期时间，已经缓存在了lists对象中，则直接找到缓存的数据 
 if (lists[msecs]) { 
  list = lists[msecs]; 
 } else { 
  // 否则，执行新建一个list数据 
  // 并把item和msecs的数据初始化到新创建的对象中去 
  list = new Timer(); 
  // 下面这些，就是Timer实例化之后，包含的方法 
  // close 
  // ref 
  // unref 
  // start 
  // stop 
  // setRepeat 
  // getRepeat 
  // again 
 
  // 实例化之后，调用start方法 
  list.start(msecs, 0); 
 
  // 把list对象，改为一个循环链表 
  L.init(list); 
 
  // 把该list添加到lists对象中缓存 
  // 并设置一些属性，这些属性，在其他方法中被用到 
  lists[msecs] = list; 
  list.msecs = msecs; 
  list[kOnTimeout] = listOnTimeout; 
 } 
 
 // 把item插入到list的下一个节点去 
 L.append(list, item); 
 assert(!L.isEmpty(list)); // list is not empty 
} 
 
// 每一个list的kOnTimeout的属性值，应该是一个回调函数 
// 所以，其内部指向的是list本事 
function listOnTimeout() { 
 var msecs = this.msecs; 
 var list = this; 
 
 debug('timeout callback %d', msecs); 
 
 // 类似一个时间戳，但是又和Date.now()的毫秒级时间戳不同，不知道是如何判断这个的 
 var now = Timer.now(); 
 debug('now: %d', now); 
 
 var diff, first, threw; 
 
 // 当时间到了之后，把对应该时间的链表中的所有元素执行 
 // 如果出现异味，则等一会再次执行，请看源码中的具体注释 
 while (first = L.peek(list)) { 
  // If the previous iteration caused a timer to be added, 
  // update the value of "now" so that timing computations are 
  // done correctly. See test/simple/test-timers-blocking-callback.js 
  // for more information. 
  // 本处的while是，把list的所有前置列表，都处理一遍，直到list所处的链表中，只有list时结束 
  if (now < first._idleStart) { 
   // 当first元素，当执行insert时，会操作_idleStart的属性值 
   // 如果Timer.now的值，是一直增加的，那么这里为神马会执行？ 
   // 那么又为什么要有这个判断？只是打了一个log，难道只是为了做个通知？ 
   now = Timer.now(); 
   debug('now: %d', now); 
  } 
 
  // 求这个差值？并且与list的msecs值进行判断 
  diff = now - first._idleStart; 
  if (diff < msecs) { 
   // 执行到这里，那边把list继续延时一段时间，因为当前的一个item没有被执行 
   // 所以重新计时，再执行一次 
   list.start(msecs - diff, 0); 
   debug('%d list wait because diff is %d', msecs, diff); 
 
   // 并且直接return，结束本回调函数，等待msecs－diff时间之后，再次执行 
   return; 
  } else { 
   // 把first从它所在的链表中移除 
   L.remove(first); 
 
   // 我觉得，这里是在判断，是否移除成功 
   assert(first !== L.peek(list)); 
 
   // 如果当前的first没有回调函数，那么不需要再向下执行，继续while循环 
   if (!first._onTimeout) continue; 
 
   // 接下来，就是执行回调的处理了，处理的逻辑还行，看起来不算复杂 
   // 只是，有些判断，我现在无法理解到，为什么要这么判断 
 
   // v0.4 compatibility: if the timer callback throws and the 
   // domain or uncaughtException handler ignore the exception, 
   // other timers that expire on this tick should still run. 
   // 
   // https://github.com/joyent/node/issues/2631 
   var domain = first.domain; 
   if (domain && domain._disposed) 
    continue; 
 
   try { 
    if (domain) 
     domain.enter(); 
    threw = true; 
    first._onTimeout(); 
    if (domain) 
     domain.exit(); 
    threw = false; 
   } finally { 
    if (threw) { 
     // We need to continue processing after domain error handling 
     // is complete, but not by using whatever domain was left over 
     // when the timeout threw its exception. 
     var oldDomain = process.domain; 
     process.domain = null; 
     process.nextTick(function() { 
      list[kOnTimeout](); 
     }); 
     process.domain = oldDomain; 
    } 
   } 
  } 
 } 
 
 debug('%d list empty', msecs); 
 assert(L.isEmpty(list)); 
 list.close(); 
 delete lists[msecs]; 
} 
 
 
var unenroll = exports.unenroll = function(item) { 
 L.remove(item); 
 
 // _idleTimeout中保存着msecs的值， 
 // 所有可以根据该属性，直接找到该对象在lists中的缓存数据 
 // 不过，item的msecs中，也保存了list本身的msecs的 
 
 var list = lists[item._idleTimeout]; 
 // if empty then stop the watcher 
 debug('unenroll'); 
 if (list && L.isEmpty(list)) { 
  debug('unenroll: list empty'); 
  // list调用C++的接口 
  list.close(); 
  delete lists[item._idleTimeout]; 
 } 
 // if active is called later, then we want to make sure not to insert again 
 item._idleTimeout = -1; 
 // 本方法，其实就是在清理一些默认的数据了 
 // 属于，当一个方法执行完之后，把其对应的数据，都直接清理掉 
 
}; 
 
 
// Does not start the time, just sets up the members needed. 
exports.enroll = function(item, msecs) { 
 // 给item重新设置一些属性 
 // msecs的值，需要时number类型，并且有效的正整数和零 
 if (!util.isNumber(msecs)) { 
  throw new TypeError('msecs must be a number'); 
 } 
 
 if (msecs < 0 || !isFinite(msecs)) { 
  throw new RangeError('msecs must be a non-negative finite number'); 
 } 
 
 // if this item was already in a list somewhere 
 // then we should unenroll it from that 
 // 保证，item不会存在于两个链表中， 
 // 比如，我最初把item设置为1000之后执行，那么item在lists[1000]所在的链表中 
 // 接下来，我又把item设置为2000之后执行，那么就要先吧item从原来的lists[1000]的链表中删除 
 // 然后，添加到lists[2000]所指向的链表去 
 if (item._idleNext) unenroll(item); 
 
 // Ensure that msecs fits into signed int32 
 // 保证是在最大值之内的，否则，设置为一个系统设置的最大值 
 if (msecs > TIMEOUT_MAX) { 
  msecs = TIMEOUT_MAX; 
 } 
 
 // 设置信息，并初始化item本身的链表 
 item._idleTimeout = msecs; 
 L.init(item); 
}; 
 
 
// call this whenever the item is active (not idle) 
// it will reset its timeout. 
exports.active = function(item) { 
 // 把item插入到缓存的lists对象中， 
 // 或者把已经存在的于对象中的item，进行一次数据更新 
 var msecs = item._idleTimeout; 
 if (msecs >= 0) { 
  // 看上面的函数，enroll可以知道，msecs是必须大于等于0的 
  var list = lists[msecs]; 
  // 如果list存在于lists中，找到对应的链表 
 
  if (!list || L.isEmpty(list)) { 
   // 如果list为空，或者list为空链接，则执行insert方法，创建一个新的链表 
   // 并且把该链表，保存到lists[msecs]中去 
   insert(item, msecs); 
  } else { 
   // 如果有，那么更新item属性的当前时间，把item插入到list链表中去 
   item._idleStart = Timer.now(); 
   L.append(list, item); 
  } 
 } 
}; 
 
 
/* 
* DOM-style timers 
*/ 
 
 
exports.setTimeout = function(callback, after) { 
 // setTimeout的实现源代码 
 // 前两个参数必须是固定的 
 var timer; 
 
 // after转化为数字，或者NaN 
 after *= 1; // coalesce to number or NaN 
 
 // 如果不在合法范围之内，则把after设置为1 
 if (!(after >= 1 && after <= TIMEOUT_MAX)) { 
  after = 1; // schedule on next tick, follows browser behaviour 
 } 
 
 // 根据Timerout构造函数，生成一个实例，该构造函数完成的功能 
 // 只是创建一个对象，设置了一些属性和一些方法 
 timer = new Timeout(after); 
 // 实例化后的timer包含以下内部属性 
 // _idleTimeout = after; 
 // _idlePrev = this; 
 // _idleNext = this; 
 // _idleStart = null; 
 // _onTimeout = null; 
 // _repeat = false; 
 // 以及一下几个原型链方法 
 // unref 
 // ref 
 // close 
 
 // 如果传入的参数，小于等于2个，说明没有多余的默认参数传入 
 if (arguments.length <= 2) { 
  timer._onTimeout = callback; 
 } else { 
 
  // 如果有多余的默认参数传入，那么就要把多余的参数缓存一下 
  // 使用闭包，重新设置一个回调函数 
  var args = Array.prototype.slice.call(arguments, 2); 
  timer._onTimeout = function() { 
   callback.apply(timer, args); 
  } 
 } 
 
 // 设置timer的domain属性为process的domain属性 
 // 该属性，暂时还不知道为什么存在 
 if (process.domain) timer.domain = process.domain; 
 
 // 把timer设置为启动，并在active中，插入到等待执行的列表中去 
 exports.active(timer); 
 
 // 返回Timeout的实例对象，所以，可以想象setTimeout的返回值，到底有哪些属性和方法了吧 
 return timer; 
}; 
 
 
exports.clearTimeout = function(timer) { 
 // 只有timer存在 
 // 回调存在，回调时间存在的情况下，才需要把该方法清理掉 
 // 至于为什么要判断这些条件，请参考listOnTimeout方法内部的注释及逻辑 
 if (timer && (timer[kOnTimeout] || timer._onTimeout)) { 
  timer[kOnTimeout] = timer._onTimeout = null; 
  // 清除回调，时间等属性，然后把timer自lists链表中，去除掉 
  // 这样减少在每次调用时，对lists中对象的无意义的循环 
  if (timer instanceof Timeout) { 
   timer.close(); // for after === 0 
  } else { 
   exports.unenroll(timer); 
  } 
 } 
}; 
 
 
exports.setInterval = function(callback, repeat) { 
 // 前期的处理，和setTimeout方法相同，唯一不同的是，回调 
 // 在本方法中，回调之后，再添加另外一个计时器 
 // 在我看来，就像是每次去调用setTimeout方法一样 
 
 repeat *= 1; // coalesce to number or NaN 
 
 if (!(repeat >= 1 && repeat <= TIMEOUT_MAX)) { 
  repeat = 1; // schedule on next tick, follows browser behaviour 
 } 
 
 var timer = new Timeout(repeat); 
 var args = Array.prototype.slice.call(arguments, 2); 
 timer._onTimeout = wrapper; 
 timer._repeat = true; 
 
 if (process.domain) timer.domain = process.domain; 
 exports.active(timer); 
 
 return timer; 
 
 function wrapper() { 
  callback.apply(this, args); 
  // If callback called clearInterval(). 
  if (timer._repeat === false) return; 
  // If timer is unref'd (or was - it's permanently removed from the list.) 
 
  // 下面的处理，是因为在net模块中，和在本模块中，重新启用一个计时器的方法有区别 
  if (this._handle) { 
   // 该分支处理，应该是为了net模块中做的处理 
   // 在本模块中，暂时是没有提及到该属性的 
   this._handle.start(repeat, 0); 
  } else { 
   // 当前的模块中的回调函数 
   timer._idleTimeout = repeat; 
   exports.active(timer); 
  } 
 } 
}; 
 
exports.clearInterval = function(timer) { 
 // 基本上，就是只有timer和repeat属性存在的情况下 
 // 才表示timer对象，是出于Interval方法中， 
 // 这个时候，才去清理掉repeat属性，然后clearTimeout的方法 
 // 清理掉该计时器 
 if (timer && timer._repeat) { 
  timer._repeat = false; 
  clearTimeout(timer); 
 } 
};