1
class PromisePool {
2
  constructor(concurrency = 5) {
3
    this.concurrency = concurrency;
4
    this.queue = [];
5
    this.running = 0;
6
    this.results = [];
7
    this.paused = false;
8
    this.pendingResolve = null;
9
    this.drainedResolve = null;
10
    this.taskStates = new Map(); // 任务ID -> 状态
11
    this.nextTaskId = 1;
12
  }
13

14
  // 添加任务
15
  add(taskFn, ...args) {
16
    const taskId = this.nextTaskId++;
17
    this.taskStates.set(taskId, 'pending');
18

19
    return new Promise((resolve, reject) => {
20
      this.queue.push({
21
        taskId,
22
        task: () => taskFn(...args),
23
        resolve,
24
        reject,
25
        args
26
      });
27

28
      this.taskStates.set(taskId, 'queued');
29
      this._maybeExecute();
30
    });
31
  }
32

33
  // 执行任务
34
  _execute({ taskId, task, resolve, reject }) {
35
    if (this.paused) return;
36

37
    this.running++;
38
    this.taskStates.set(taskId, 'running');
39

40
    Promise.resolve()
41
      .then(task)
42
      .then(result => {
43
        resolve(result);
44
        this.results.push(result);
45
        this.taskStates.set(taskId, 'fulfilled');
46
        return result;
47
      })
48
      .catch(error => {
49
        reject(error);
50
        this.taskStates.set(taskId, 'rejected');
51
        return error;
52
      })
53
      .finally(() => {
54
        this.running--;
55
        this.taskStates.delete(taskId);
56

57
        if (this.pendingResolve) {
58
          this.pendingResolve();
59
          this.pendingResolve = null;
60
        }
61

62
        this._maybeExecute();
63

64
        if (this.queue.length === 0 && this.running === 0 && this.drainedResolve) {
65
          this.drainedResolve(this.results);
66
        }
67
      });
68
  }
69

70
  // 调度任务
71
  _maybeExecute() {
72
    while (this.running < this.concurrency && this.queue.length > 0 && !this.paused) {
73
      const task = this.queue.shift();
74
      this._execute(task);
75
    }
76
  }
77

78
  // 暂停执行
79
  pause() {
80
    this.paused = true;
81
  }
82

83
  // 恢复执行
84
  resume() {
85
    this.paused = false;
86
    this._maybeExecute();
87
  }
88

89
  // 等待所有任务完成
90
  async drain() {
91
    if (this.queue.length === 0 && this.running === 0) {
92
      return this.results;
93
    }
94

95
    return new Promise(resolve => {
96
      this.drainedResolve = resolve;
97
    });
98
  }
99

100
  // 等待空闲槽位
101
  async onIdle() {
102
    if (this.running < this.concurrency) return;
103

104
    return new Promise(resolve => {
105
      this.pendingResolve = resolve;
106
    });
107
  }
108

109
  // 获取任务状态
110
  getTaskState(taskId) {
111
    return this.taskStates.get(taskId) || 'unknown';
112
  }
113

114
  // 获取统计信息
115
  getStats() {
116
    return {
117
      total: this.results.length + this.running + this.queue.length,
118
      completed: this.results.length,
119
      running: this.running,
120
      queued: this.queue.length,
121
      concurrency: this.concurrency
122
    };
123
  }
124
}