javascript task pool的设计与实现

先简单描述一下这个 task pool的设计初衷，毕竟脱离实际谈设计都是耍流氓。

我需要这样一个Task Pool：

1. 能够指定任务运行的最大并发数量，超出运行池的任务进行排队；

2. 每一个任务都能够具备相当的灵活性；

3. 任务执行完成后能够根据任务的执行结果进行进一步的处理；

4. js中有大量的异步任务和回调，因此经常会有回调的顺序和依赖问题（例如等待多个异步请求执行完成再执行下一步）；

5. 最终业务上使用简单，最好一行代码搞定；

结合一个ajax请求纳入任务池管理的具体业务，在进一步解释设计和实现之前介绍一下结构分层，这是我在设计过程中的基本原则：

1. 通用的task pool抽象: MergeableTaskPool （与业务无关，主要解决任务的调度、并发和排队的问题）；

2. 通用的batch处理：BatchTaskPool （与业务无关，主要解决等待多个任务处理完成的问题，这多个任务之间可以并行）；

3. 与业务相关的具体task manager：PooledAjaxManager（与业务相关，定义具体业务操作，离业务较近，因此封装需要足够轻量，摆脱重复干脏活累活）；

4. 业务层接口：AjaxUtils（离用户/开发者最近的接口，因此易用性是最重要的）；

在看task pool的代码实现前先看一下他的使用方式：

AjaxUtils.batchPost(postTasks,
	function(task, result) { 
		console.log('post complete: ' + task.id); 
	},
	function(batchId) { 
		console.log('batch complete: ' + batchId) 
	}
);

这里使用了一个工具类来封装ajax请求的调用，通过工具类执行的所有ajax请求都会纳入到 Task Pool的管理范围，只有当前面的请求已经执行完成，才会开始执行后面的请求，以队列的方式排队执行。当然既然叫做Task Pool，多个请求之间需要具备并发的能力。

从这里展现了业务接口最终的使用方式很简单（业务层的使用方式必需要有亲和性，否则就失去了封装的意义）：

1. 把每一个要通过ajax操作的信息打包成一个一个的Task对象（url, data 等）

2. Task对象可以一个一个的进入队列，也可以一批次的压入队列

3. 对于单个任务提供了回调方法，并且能够把业务处理的结果也带回给回调方法

4. 如果是批量处理，那么除了单个任务执行完成能够收到回调以外，整个批次处理完成也能收到一个独立的批次完成的回调

提供给最终业务使用的封装之下是具体业务的逻辑实现，工具类的实现很容易（这里可以看到，ajax请求允许同时存在3个并发）：

var AJAX_POOLED_MANAGER = new PooledAjaxManager(3);

  static batchPost(postTasks, callback, batchCallabck) {
  	AJAX_POOLED_MANAGER.addBatch(BaseUtils.uniqId(), postTasks, callback, batchCallabck);
  }

具体业务层的实现也需要保持清爽，如果每个业务层pool的实现都要写大段的代码，那么Task Pool就没有任何设计可言了：

class PooledAjaxManager extends BatchTaskPool
 {
	constructor(limit) {
		super(limit);
	}

	process(taskId, task, resolve) {
		AjaxUtils.post(task.url, task.data, 
			function(success, data) {
				resolve({success: success, data: data});
			}
		);
	}
}

简单描述下上面这段代码，这个是具体业务层manager的实现，与通用Task Pool解耦的思想也就包含在其中。这段代码只做了两件事：

1. 每一个manager可以独立指定任务的并发数量；

2. process 实现具体业务调用的逻辑，执行业务调用所需的数据都包含在之前传入pool的task对象中了。

这里比较重要的是resolve参数，因为javascript里处处都充满了异步处理和回调，因此怎么把异步做得更简单非常重要。因此我们提供了一个resolve方法，只要调用resolve方法就表明这个任务可以结束了，这和Promise的思想是相似的。同时resolve能够把任务的处理结果带回到业务层，也就是最上层封装单个任务执行完成通知回调的result参数。

这里没有贴出AjaxUtils.post方法的实现，因为实际上就是jQuery $.post 的简单调用而已，唯一的区别是把jquery ajax的 success 和 error 回调统一成了一个。

再下一层，当然就是通用 Task Pool的具体实现了，show me the code阶段（由于具体业务的需要）：

class BatchTaskPool {
  constructor(limit) {
    this.callbacks = new MapArray(); // { taskId: [ callabck ... ] }
    this.taskBatches = new MapArray(); // { taskId: [ batchId ... ] }
    this.batchCallbacks = {}; // { batchId: batchCallback }
    this.batchTasks = {}; // { batchId: { taskId: } }
    this.taskPool = new MergeableTaskPool({
      limit: limit || 5,
      process: this.process.bind(this),
      taskCallback: this.onTaskComplete.bind(this),
      complete: this.onTaskPoolIdle.bind(this)
    });
  }

  // add single task
  add(task, callback) {
    let self = this;
    this.taskPool.push(task.id, task);
    this.callbacks.add(task.id, callback);
  }

  // add batch tasks
  addBatch(batchId, tasks, callback, batchCallback) {
    // map batchId to {taskId:true}
    let batchTaskMap = this.batchTasks[batchId] || {};
    let manager = this;

    BaseUtils.each(tasks, function(task){
      manager.callbacks.add(task.id, callback);
      manager.taskPool.push(task.id, task);
      manager.taskBatches.add(task.id, batchId);
      batchTaskMap[task.id] = true;
    });

    this.batchTasks[batchId] = batchTaskMap;
    this.batchCallbacks[batchId] = batchCallback;
  }

  // process single task
  process(taskId, task, resolve) {
    console.warn('method "process" should be overrided!')
    setTimeout(resolve, 10);
  }

  // single task complete
  onTaskComplete(taskId, task, result) {
    let self = this;
    let callbacks = this.callbacks.remove(taskId);
    let taskBatches = this.taskBatches.get(taskId);
    BaseUtils.each(callbacks, function(callback){
      ScCallback(callback, self, task, result);
    })

    // remove taskId 
    BaseUtils.each(taskBatches, function(batchId){
      let batchIds = self.batchTasks[batchId];
      if( batchIds ) {
        delete batchIds[taskId];
        if( BaseUtils.isEmpty(batchIds)) {
          let batchCallback = self.batchCallbacks[batchId];
          delete self.batchCallbacks[batchId];

          self.onBatchComplete.call(this, batchId, batchCallback);
        }
      }
    });
  }

  // batch complete
  onBatchComplete(batchId, batchCallback) {
    ScCallback(batchCallback, this, batchId);
  }

  onTaskPoolIdle() {
  }
}

这里主要做的事情是为了实现批量回调的逻辑，这一点从constructor里初始化的数据结构里可以看出来。

class MergeableTaskPool {
  constructor(options) {
    this.options = options || {};
    options = this.options;

    this.active = 0;
    this.limit = options.limit || 5;
    this.running = new MapArray();
    this.queue = new LinkedSet();
    this.cached = new MapArray();
  }

  // add a task into pool, make it queued on running pool full filled
  push(key, task) {
    // key existed in running pool, need no wait for queue
    if( this.running.get(key)) {
      return this.running.add(key, task);
    }
    // execute task at once while there's quota in running queue
    if( this.active < this.limit) {
      return this.execute(key, task);
    }
    // otherwise, queue the task to be scheduled later
    return this.cache(key, task);
  }

  // execute task at one without wating
  execute(key, task) {
    this.running.add(key, task);
    this.active ++;
    // perform the task execute process, only execute the first node of the array
    ScCallback(this.options.process, this.options, key, task, this.resolve.bind(this, key));
  }

  // add a task into queue of waiting scehduled
  cache(key, task) {
    this.queue.push(key);
    this.cached.add(key, task);
  }

  // schedule tasks to make sure the usage of running pool
  schedule() {
    let count = this.limit - this.active;
    let scheduleCount = Math.min(count, this.queue.length());
    for( let i = 0; i < scheduleCount; i ++ ) {
      let key = this.queue.shift();
      let tasks = this.cached.remove(key);
      if( tasks && tasks[0]) {
        this.execute(key, tasks[0]);
      }
    }
  }

  // mark running of key finished
  resolve(key, result) {
    if( this.running.get(key)) {
      let tasks = this.running.remove(key);
      this.active --;
      // call the complete callback while no more tasks need to be schedule
      let task = (tasks && tasks.length && tasks[0]) || {};
      this.taskFinished.call(this, key, task, result);

      if( this.active == 0 && this.queue.isEmpty() ) {
        return this.taskPoolEmpty();
      }
    }

    setTimeout( this.schedule.bind(this), 10);
  }

  taskFinished(key, task, result) {
    ScCallback(this.options.taskCallback, this, key, task, result);
  }

  // call the complete callback while no more tasks need to be schedule
  taskPoolEmpty() {
      ScCallback(this.options.complete, this);
  }
}

这里才是最底层的任务池实现，这里做了一点特殊处理，主要是为了避免重复处理单个任务。

这里也展现了resolve方法的具体实现，其中 setTimeout 10ms的做法还有待商榷。

在实现时基础数据结构的使用也很重要，虽然这里用的都是最简单的，但是有了这些基础结构以后就事半工倍了，平时工作中不时进行抽象和沉淀也是一个好习惯。

虽然这个设计和实现是围绕具体业务逻辑展开的，但是在做的时候能够更多地去思考他的更多的应用场景。例如，不妨试着回答一个问题：这里上层业务是为了让ajax请求单独new了一个专用ajax manager，如果业务里任务没有这么强的共性但是又需要batch处理的能力怎么办呢？那么回答应该也很简单，只需要把业务处理的function也打包进task对象就可以了，上层manager封装的process方法只需要调用task.func并确保resolve方法的调用就行了。