控制并发执行函数 #

type TTask = (...args: any[]) => Promise<any>;

type TTaskResult = {
	status: 'resolved' | 'rejected';
	value?: any;
	reason?: any;
}

type TParallelCallResult = {
	resolved: ITaskResult[];
	rejected: ITaskResult[];
}

export const parallelCallTasks = (tasks: TTask[], concurrentNum: number) => {
	return new Promise((resolve, reject) => {
	  const queue: (() => TTask)[] = [];
	  const resolved: ITaskResult[] = [];
	  const rejected: ITaskResult[] = [];
	  let idx = 0;
	  let finishedIdx = 0;
	  const next = (task: TTask) => {
		  idx++;
		  task()
          .then(res => {
              resolved.push({ status: 'resolved', value: res })
          })
          .catch(reason => {
              rejected.push({ status: 'rejected', reason })
          })
          .finally(() => {
	          if(finishedIdx++ === tasks.length - 1) {
		          resolve({ resolved, rejected });
		          return;
	          }
              idx--;
              const fn = queue.shift();
              if(!!fn) {
                  fn();
              }
          })
    }
	tasks.forEach(task => {
		if (idx >= concurrentNum) {
			queue.push(() => next(task))
            return
        }
		next(task)
    })
  })
}