并发控制是限制同时执行的异步任务数量以避免资源过载；不能直接用Promise.all是因为它会无节制并行发起所有请求，易触发后端限流、浏览器连接限制、内存/CPU过载或雪崩。
什么是并发控制，为什么不能直接 Promise.all 一把梭？
当多个异步任务（比如 API 请求、文件读取）同时发起时，Promise.all 会并行启动全部任务——这在低并发场景下没问题，但遇到以下情况就会出问题：
• 后端限流（如 503 Too Many Requests）
• 浏览器对同一域名的并发连接数限制（通常 6 个）
• 内存或 CPU 过载（尤其处理大量图片/视频 blob）
• 需要按顺序“节流”执行，避免雪崩
用 Promise.allSettled + 手动分批最简单可靠
不依赖第三方库，适合中低复杂度场景。核心思路是把任务数组切片，每批最多 n 个，等一批全完成再发下一批。
function limitConcurrency(tasks, limit = 3) {
const results = [];
let index = 0;
<p>async function runBatch() {
const batch = tasks.slice(index, index + limit);
if (batch.length === 0) return;
index += limit;</p><pre class='brush:php;toolbar:false;'>const batchResults = await Promise.allSettled(batch);
results.push(...batchResults);
await runBatch(); // 串行递归}
return runBatch().then(() => results); }
// 用法：传入一个 Promise 工厂数组，而非已触发的 Promise const apiCalls = [ () => fetch('/api/user/1'), () => fetch('/api/user/2'), () => fetch('/api/user/3'), // ... ]; limitConcurrency(apiCalls.map(fn => fn())).then(console.log);
⚠️ 注意：
• 一定要传 () => fetch(...)，不是 fetch(...)，否则调用时就已发起请求
• Promise.allSettled 确保失败任务不中断整个流程
• 递归调用需小心栈溢出（>1000 批建议改用循环 + await）
立即学习“Java免费学习笔记（深入）”；
用 async-pool 库做生产级并发管理
如果项目允许引入轻量依赖，async-pool 是目前最稳定的选择（仅 1.5KB，无副作用）。它支持真正的“运行中动态控流”，比手动分批更精准。
安装：npm install async-pool
import { pool } from 'async-pool';
<p>const results = await pool(4, apiCalls, async (call) => {
const res = await call();
return res.json();
});关键点：
• 第一个参数是最大并发数（4）
• 第二个参数是待执行函数数组（不是 Promise！）
• 第三个参数是每个函数的包装逻辑，返回值会收集进 results
• 自动处理错误、暂停、重试（需自行封装）
自定义 concurrent 类：需要取消、优先级或进度回调时
当业务要求更高控制力（比如用户点击“取消所有请求”，或某任务必须插队），就得自己封装类。核心是维护一个任务队列 + 正在运行的任务 Set。
class ConcurrentExecutor {
constructor(limit = 3) {
this.limit = limit;
this.queue = [];
this.running = new Set();
}
<p>add(promiseFactory, priority = 0) {
return new Promise((resolve, reject) => {
this.queue.push({ promiseFactory, resolve, reject, priority });
this.#run();
});
}</p><h1>run() {</h1><pre class='brush:php;toolbar:false;'>if (this.running.size >= this.limit || this.queue.length === 0) return;
// 按 priority 排序（高优先级先执行）
this.queue.sort((a, b) => b.priority - a.priority);
const { promiseFactory, resolve, reject } = this.queue.shift();
const task = promiseFactory();
this.running.add(task);
task.then(resolve).catch(reject).finally(() => {
this.running.delete(task);
this.#run(); // 尝试启动下一个
});} }
使用示例：
const executor = new ConcurrentExecutor(2);<br>executor.add(() => fetch('/api/slow'), 10); // 高优<br>executor.add(() => fetch('/api/fast'), 1); // 低优⚠️ 注意：取消能力需在
promiseFactory 内部用 AbortController 实现，Executor 本身不介入 Promise 内部逻辑
真正难的不是写个能跑的并发控制器，而是判断什么时候该用分批、什么时候该用池、什么时候必须自己造轮子——尤其当接口响应时间差异大、失败率高、或前端要暴露“正在运行 X/10”这类状态时，静态 limit 很容易变成瓶颈。
