How to implement Ajax concurrent request control based on JS

    const delay = function delay(interval) {
      return new Promise((res,rej) => {
        setTimeout(() => {
          res(interval)
        }, interval);
      })
    }


    let tasks = [() => {
      return delay(1000)
    },() => {
      return delay(1003)
    },() => {
      return delay(1005)
    },() => {
      return delay(1002)
    },() => {
      return delay(1004)
    },() => {
      return delay(1006)
    }]

    // Implement parallelism through Promise.all Promise.all(tasks.map(task => task())).then(res => {
      console.log(res);
    })

    // Implement function creatRequest(tasks,pool) based on Promise {
      // The number of requests sent each time is controlled by the pool
      pool = pool || 5
      // Used to store the results of each request (stored in order)
      let results = [],
      // together is used to create workspaces. When pool is passed in, we create several workspaces accordingly. // That is, create an array with the length of pool and the value of null together = new Array(pool).fill(null),
      // index is the task value obtained each time index = 0;
      together = together.map(() => {
        // Management based on Promise return new Promise((resolve,reject) => {
          // Create a function and execute it immediately const run = function run() {
            // If the task pool is empty, it means the request has been sent successfully if(index >= tasks.length) {
              resolve()
              return 
            }
            // First save the index to store the result of the current successful request let old_index = index,
            // Get the currently sent request, and then accumulate the index, so the index will be saved above // ​​Here index++ is calculated first and then accumulated, while ++index is the opposite, first accumulate and then calculate task = tasks[index++];
            // Execute request task().then(result => {
            // Save the successful result results[old_index] = result
            // Recursively continue to execute, that is, continue to get the task to the workspace to execute run();
            }).catch(reason => {
              reject(reason)
            })
          }
          // Execute run() immediately
        })
      })
      // Use Promise.all to control the workspace, that is, make two requests concurrently at a time return Promise.all(together).then(() => results)
    }


    creatRequest(tasks,2).then(results => {
      // All must be successful for the whole to succeed, store the results in order console.log('success',results);
    }).catch(resolve => {
      // If only one of them fails, the whole system will fail console.log('failed');
    })



    // Implement function creatRequest(tasks,pool,callback) based on Class {
      // Parameter restriction and verification if(typeof pool === 'function') {
        callback = pool;
        pool = 5
      }
      if (typeof pool !== 'number') pool = 5
      if (typeof callback !== 'function') callback = function () {}
      //------
      class TaskQueue {
        // Number of running runs = 0;
        // Queue all tasks in queue = [];
        //Store the results of executing tasks (requests) results = [];
        pushTask(task) {
          let self = this
          // Push the task into the workspace self.queue.push(task)
          // Execute the logic of sending the request self.next()
        }
        next() {
          let self = this
          // When the number of tasks being executed is less than the concurrency, continue to take tasks to execute while(self.runing < pool && self.queue.length) {
            self.running++;
            // It is equivalent to taking a task and deleting a task let task = self.queue.shift();
            // Execute request task().then(result => {
              //Save the execution results self.results.push(result)
            }).finally(() => {
              // Clear the number of running items self.runing--
              // Continue executing the request self.next()
            })
          }
          // When there are no tasks, the loop ends if(self.runing === 0) callback(self.results)
        }


      }
      // Instantiation let TQ = new TaskQueue()
      tasks.forEach(task => TQ.pushTask(task))
    }


    creatRequest(tasks,2,results=> {
      console.log(results);
    })