extjs源码分析-Ext.util.TaskRunner(模拟多线程)

/**
 * @class Ext.util.TaskRunner
 * @description 模拟多线程的JS类
//一个简单的更新闹钟时间的任务
var updateClock = function(){
    Ext.fly('clock').update(new Date().format('g:i:s A'));
} 
var task = {
    run: updateClock,
    interval: 1000 //1 秒
}
var runner = new Ext.util.TaskRunner();//实例化一个线程管理器
runner.start(task);//开始执行task线程
//下面是简易的写法
Ext.TaskMgr.start({
    run: updateClock,
    interval: 1000
});
 * 对比查看{@link Ext.util.DelayedTask}. 
 * @constructor
 * @param {Number} interval 这个设置线程管理器的执行时间，默认为10毫秒
 * (defaults to 10)
 */
Ext.util.TaskRunner = function(interval){
    interval = interval || 10;
    var tasks = [], //任务集合
    	removeQueue = [],//被移除的任务
    	id = 0,//定时器ID
    	running = false,//是否正在执行

    	// private
    	stopThread = function(){//停止执行，并把running 和 id 重置
	        running = false;
	        clearInterval(id);
	        id = 0;
	    },

    	// private
    	startThread = function(){//开始执行，确定当前进程还没执行
	        if(!running){
	            running = true;
	            id = setInterval(runTasks, interval);
	        }
	    },

    	// private
    	removeTask = function(t){//删除进程，
	        removeQueue.push(t);//把不要再执行的进程放到removeQueue数组中，以等待下次执行其他进程的时候把删除掉
	        if(t.onStop){//进程停止后的回调函数
	            t.onStop.apply(t.scope || t);
	        }
	    },
	    
    	// private
    	runTasks = function(){
	    	var rqLen = removeQueue.length,//获取被
	    		now = new Date().getTime();	    			    		
	    
	        if(rqLen > 0){
	            for(var i = 0; i < rqLen; i++){
	                tasks.remove(removeQueue[i]);//把removeQueue中的值从tasks中移除
	            }
	            removeQueue = [];//重新重置 removeQueue
	            if(tasks.length < 1){//如果进程数为0，那直接返回，并停止当前正在执行的进程
	                stopThread();
	                return;
	            }
	        }	        
	        for(var i = 0, t, itime, rt, len = tasks.length; i < len; ++i){
	            t = tasks[i];
	            itime = now - t.taskRunTime;//当前时间 - 线程的最后一次运行的时间
				//因为这个函数默认的interval为10，也就是整个线程实例是每隔10毫秒会去监控一次是否有需要运行的任务,
				//这样做的原因是保障每个任务的定时器可以不一样，但都能执行得到，这就是这个函数能支持多个定时任务的原因所在，其实也就是模拟了多线程
	            if(t.interval <= itime){
	                rt = t.run.apply(t.scope || t, t.args || [++t.taskRunCount]);
	                t.taskRunTime = now;//重新更新当前线程的执行时间
					//如果线程结束，则删除当前线程 
	                if(rt === false || t.taskRunCount === t.repeat){
	                    removeTask(t);
	                    return;
	                }
	            }
				//如果存在 duration 并且已经超出了执行时间了，比如我要求这个线程执行时间 即duration 为一分钟，
				//那么我这个任务已经执行时间(当前时间 - 线程开始执行的时间)必须小于 一分钟，否则的话那这个线程就得删除
	            if(t.duration && t.duration <= (now - t.taskStartTime)){
	                removeTask(t);
	            }
	        }
	    };

    /**
     * Starts a new task.
     * @method start
     * @param {Object} task 配置属性:<ul>
     * <li>run : Function 每次执行的回调函数，参数为 下面的 args 或者 当前线程被执行的次数 </li>
     * <li>args : Array 这个值穿给上面的function</li>
     * <li>scope : Object 线程执行的作用域 默认为当前的线程 </li>
     * <li>duration : Number (optional) 执行的时长，单位是毫秒</li>
     * <li>repeat : Number(optional) 线程执行的次数</li>
     * </ul>
     * @return {Object} The task
     */
    this.start = function(task){
        tasks.push(task);
        task.taskStartTime = new Date().getTime();//线程开始执行的时间
        task.taskRunTime = 0;//线程执行的的时间 这个是以毫秒为单位的数字 1000便是一秒
        task.taskRunCount = 0;//线程执行的次数
        startThread();
        return task;
    };

    /**
     * @description 停止某个线程执行
     * @method stop
     * @param {Object} task 被停止的线程
     * @return {Object} 返回被停止的线程
     */
    this.stop = function(task){
        removeTask(task);
        return task;
    };

    /**
     * @description 停止所有线程.
     * @method stopAll
     */
    this.stopAll = function(){
        stopThread();
        for(var i = 0, len = tasks.length; i < len; i++){
            if(tasks[i].onStop){
                tasks[i].onStop();
            }
        }
        tasks = [];
        removeQueue = [];
    };
};
//多线程实例化对象
Ext.TaskMgr = new Ext.util.TaskRunner();