并发控制是限制同时执行的异步任务数量以避免资源过载；不能直接用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; 
async function runBatch() { const batch = tasks.slice(index, index + limit); if (batch.length === 0) return; index += limit;
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'; 
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();   } 
add(promiseFactory, priority = 0) { return new Promise((resolve, reject) => { this.queue.push({ promiseFactory, resolve, reject, priority }); this.#run(); }); }
run() {
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);
executor.add(() => fetch('/api/slow'), 10); // 高优
executor.add(() => fetch('/api/fast'), 1);  // 低优
⚠️ 注意：取消能力需在 promiseFactory 内部用 AbortController 实现，Executor 本身不介入 Promise 内部逻辑
真正难的不是写个能跑的并发控制器，而是判断什么时候该用分批、什么时候该用池、什么时候必须自己造轮子——尤其当接口响应时间差异大、失败率高、或前端要暴露“正在运行 X/10”这类状态时，静态 limit 很容易变成瓶颈。