5.实现并发任务

// 示例：同时发起多个请求（无并发控制）
async function runConcurrentTasks(tasks) {
  const results = await Promise.all(tasks.map((task) => task()));
  return results;
}

// 使用
const tasks = [fetchData1, fetchData2, fetchData3];
runConcurrentTasks(tasks).then((results) => {
  console.log("所有任务完成:", results);
});

class ConcurrencyController {
  constructor(maxConcurrency) {
    this.maxConcurrency = maxConcurrency; // 最大并发数
    this.taskQueue = []; // 任务队列
    this.runningCount = 0; // 当前运行中的任务数
  }

  // 添加任务到队列
  addTask(task) {
    return new Promise((resolve, reject) => {
      this.taskQueue.push({ task, resolve, reject });
      this._run();
    });
  }

  // 执行任务（内部方法）
  _run() {
    while (
      this.runningCount < this.maxConcurrency &&
      this.taskQueue.length > 0
    ) {
      const { task, resolve, reject } = this.taskQueue.shift();
      this.runningCount++;
      task()
        .then(resolve)
        .catch(reject)
        .finally(() => {
          this.runningCount--;
          this._run(); // 递归触发下一个任务
        });
    }
  }
}

// 初始化控制器（最大并发数=2）
const controller = new ConcurrencyController(2);

// 模拟异步任务（如API请求）
function createTask(id, delay) {
  return () =>
    new Promise((resolve) => {
      setTimeout(() => {
        console.log(`任务 ${id} 完成`);
        resolve(id);
      }, delay);
    });
}

// 添加5个任务（每个任务耗时不同）
const tasks = [
  createTask(1, 1000),
  createTask(2, 500),
  createTask(3, 800),
  createTask(4, 300),
  createTask(5, 1200),
];

// 并发执行任务（最多同时2个）
tasks.forEach((task) => {
  controller.addTask(task).then((result) => {
    console.log("任务结果:", result);
  });
});

// 输出：
// 任务 2 完成 (500ms后)
// 任务 4 完成 (300ms后，任务3被提前触发)
// 任务 3 完成 (800ms后)
// 任务 1 完成 (1000ms后)
// 任务 5 完成 (1200ms后)

class AdvancedConcurrencyController extends ConcurrencyController {
  addTask(task, priority = 0) {
    return new Promise((resolve, reject) => {
      // 根据优先级插入队列（priority值越小优先级越高）
      const queueItem = { task, resolve, reject, priority };
      let index = this.taskQueue.findIndex((item) => item.priority > priority);
      index = index === -1 ? this.taskQueue.length : index;
      this.taskQueue.splice(index, 0, queueItem);
      this._run();
    });
  }
}

// 使用示例
const advancedController = new AdvancedConcurrencyController(2);
advancedController.addTask(createTask("高优先级", 500), 1);
advancedController.addTask(createTask("低优先级", 1000), 2);

class RetryConcurrencyController extends ConcurrencyController {
  constructor(maxConcurrency, maxRetries = 3) {
    super(maxConcurrency);
    this.maxRetries = maxRetries;
  }

  async _executeTaskWithRetry(task, resolve, reject) {
    let retries = 0;
    const execute = async () => {
      try {
        const result = await task();
        resolve(result);
      } catch (error) {
        if (retries < this.maxRetries) {
          retries++;
          console.log(`任务重试中（第${retries}次）`);
          await execute();
        } else {
          reject(error);
        }
      }
    };
    await execute();
  }

  _run() {
    // 重写 _run 方法，替换任务执行逻辑
    while (
      this.runningCount < this.maxConcurrency &&
      this.taskQueue.length > 0
    ) {
      const { task, resolve, reject } = this.taskQueue.shift();
      this.runningCount++;
      this._executeTaskWithRetry(task, resolve, reject).finally(() => {
        this.runningCount--;
        this._run();
      });
    }
  }
}