JS异步调度器

一个带并发限制的异步调度器，保证同时最多运行2个任务

class Scheduler {
    constructor(limit) {
      this.queue = []
      this.limit = limit
      this.count = 0
    }
    add(time, order) {
      const promiseCreator = () => {
        return new Promise((resolve, reject) => {
          setTimeout(() => {
            console.log(order)
            resolve()
          }, time)
        })
      }
      this.queue.push(promiseCreator)
    }
    taskStart() {
      for(let i = 0; i < this.limit; i++) {
        this.request()
      }
    }
    request() {
      if (!this.queue.length || this.count >= this.limit) return
      this.count++
      this.queue.shift()().then(() => {
        this.count--
        this.request()
      })
    }
  }
  // 测试代码
  const scheduler = new Scheduler(2);
  const addTask = (time, order) => {
    scheduler.add(time, order);
  };
  addTask(1000, "1");
  addTask(500, "2");
  addTask(300, "3");
  addTask(400, "4");
  scheduler.taskStart();

456

class Scheduler {
	constructor() {
		this.tasks = [], // 待运行的任务
		this.usingTask = [] // 正在运行的任务
	}
	// promiseCreator 是一个异步函数，return Promise
	add(promiseCreator) {
		return new Promise((resolve, reject) => {
			promiseCreator.resolve = resolve
			if (this.usingTask.length < 2) {
				this.usingRun(promiseCreator)
			} else {
				this.tasks.push(promiseCreator)
			}
		})
	}
	usingRun(promiseCreator) {
		this.usingTask.push(promiseCreator)
		promiseCreator().then(() => {
			promiseCreator.resolve()
			this.usingMove(promiseCreator)
			if (this.tasks.length > 0) {
				this.usingRun(this.tasks.shift())
			}
		})
	}
 
	usingMove(promiseCreator) {
		let index = this.usingTask.findIndex(promiseCreator)
		this.usingTask.splice(index, 1)
	}
}
 
const timeout = (time) => new Promise(resolve => {
	setTimeout(resolve, time)
})
 
const scheduler = new Scheduler()
 
const addTask = (time, order) => {
	scheduler.add(() => timeout(time)).then(() => console.log(order))
}
 
addTask(400, 4) 
addTask(200, 2) 
addTask(300, 3) 
addTask(100, 1) 
 
// 2, 4, 3, 1