用NodeJs实现延迟调用，规避定时任务的闭包问题

很多人在用NodeJs的setTimeout(callback, delay[, arg][, ...])编写定时任务时，习惯上直接操作callback外部的对象object（闭包的特点）。这样做有一个隐患，就是当callback真正执行的时候，外部对象object可能已经被销毁了（比如执行了自定义的销毁方法），导致对object进行的处理结果出现了很大的偏差，程序甚至有可能出现异常而退出。

解决这个问题其实很简单，我们只需要在callback回调中重新通过某种方式获取该对象，检查一下该对象是否已被销毁，即可避免上面描述的问题。但是，当程序中需要很多这样的需求时，并且是一个团队在合作写代码，这样就很难避免上述情况的发生。为了规避定时任务的闭包问题，我写了一个延迟调用类，代码如下：

/**
 * script: delayCall.js
 * description: 延迟调用，规避定时任务的闭包问题
 * authors: alwu007@sina.cn
 * date: 2016-04-19
 */

var util = require('util');
var PQueue = require('./pqueue').PQueue;

/**
 * 延迟调用类
 * @param search_func 对象查找函数
 */
var DelayCall = exports.DelayCall = function(search_func) {
    //延迟调用序号
    this._call_seq = 0;
    //延迟调用映射
    this._call_map = {};
    //延迟调用队列
    this._call_queue = new PQueue(DelayCall.compare);
    //对象查找方法
    this._search_func = search_func;

    //设置间隔定时器。FIXME：可以改为在框架的心跳机制中去执行run方法
    //注：setTimeout不支持修改系统时间
    this._interval_id = setInterval(() => {
        this.run();
    }, 1000);
};

//比较延迟调用
DelayCall.compare = function(call1, call2) {
    var time_diff = call1.exec_time - call2.exec_time;
    if (time_diff) {
        return time_diff;
    } else {
        return call1._call_id - call2._call_id;
    }
};

//延迟调用序号自增
DelayCall.prototype._addSequence = function() {
    return ++ this._call_seq;
};

/**
 * 延迟调用
 * @param id 对象查找方法_search_func根据id查找出调用者对象
 * @param method_name 调用者对象上要延迟调用的方法名
 * @param params 要延迟调用的方法参数
 * @param delay 延迟时间，单位秒
 */
DelayCall.prototype.call = function(id, method_name, params, delay) {
    var call_id = this._addSequence();
    var exec_time = Date.now() + delay * 1000;
    var call_elem = {
        _call_id: call_id,
        id: id,
        method_name: method_name,
        params: params,
        delay: delay,
        exec_time: exec_time,
        _canceled: false,
    };
    this._call_queue.enQueue(call_elem);
    this._call_map[call_id] = call_elem;
    return call_id;
};

//取消延迟调用
DelayCall.prototype.cancelCall = function(call_id) {
    var call_elem = this._call_map[call_id];
    if (call_elem) {
        delete this._call_map[call_id];
        call_elem._canceled = true;
    }
};

//运转一次
DelayCall.prototype.run = function() {
    var now = Date.now();
    var pqueue = this._call_queue;
    var search_func = this._search_func;
    var call_elem = pqueue.getHead();
    while (call_elem) {
        if (call_elem._canceled) {
            pqueue.deQueue();
        } else {
            if (now < call_elem.exec_time) {
                break;
            } else {
                //从队列和映射中删除
                pqueue.deQueue();
                delete this._call_map[call_elem._call_id];
                //执行对象的方法
                var obj = search_func(call_elem.id);
                if (obj && typeof obj[call_elem.method_name] == 'function') {
                    obj[call_elem.method_name](call_elem.params);
                }
            }
        }
        call_elem = pqueue.getHead();
    }
};

PQueue的实现请参考我的饿另一篇博文：用NodeJs实现优先级队列PQueue