p-limit vs p-queue vs p-throttle：异步并发控制深度解析

在构建高性能的前端或 Node.js 应用时，管理异步操作的并发量至关重要。无节制的并发可能导致浏览器卡顿、服务器过载或触发 API 速率限制。p-limit、p-queue 和 p-throttle 是 JavaScript 生态中解决这些问题的三个核心工具。虽然它们都涉及“控制执行”，但侧重点完全不同。让我们深入对比它们的工作原理和适用场景。

🚦 核心机制：并发数 vs 队列 vs 时间间隔

这三个库解决了异步流程中三个不同维度的问题。

p-limit 关注的是**“同时能跑几个”**。 它像一个并发控制器，确保同一时刻只有固定数量的 Promise 在运行。多余的请求会排队等待，直到有名额空出。

// p-limit: 限制并发数为 2
import pLimit from 'p-limit';

const limit = pLimit(2);

const input = [1, 2, 3, 4, 5];
// 同时最多只有 2 个 fetcher 在运行
const result = await Promise.all(input.map(id => limit(() => fetcher(id))));

p-queue 关注的是**“任务怎么排队和执行”**。 它是一个完整的任务队列，不仅限制并发，还支持优先级、超时、以及监听队列清空事件。

// p-queue: 带优先级的队列
import PQueue from 'p-queue';

const queue = new PQueue({ concurrency: 2 });

// 普通任务
queue.add(() => fetcher('normal'));
// 高优先级任务（插队）
queue.add(() => fetcher('urgent'), { priority: 10 });

// 等待所有任务完成
await queue.onIdle();

p-throttle 关注的是**“多久能跑一次”**。 它基于时间窗口进行限流，确保函数在特定时间间隔内只执行固定次数，不管并发如何。

// p-throttle: 限制每秒最多 1 次
import pThrottle from 'p-throttle';

const throttle = pThrottle({
	limit: 1,
	interval: 1000
});

const throttledFetcher = throttle(id => fetcher(id));

// 即使瞬间调用 10 次，也会按时间间隔依次执行
input.forEach(id => throttledFetcher(id));

📥 任务提交方式：包装函数 vs 队列实例

API 的设计反映了它们的使用模式。

p-limit 返回一个包装函数。 你需要用这个限制函数包裹你的异步任务生成器。它非常适合嵌入到现有的 Promise.all 或 map 操作中。

// p-limit: 包装器模式
const limit = pLimit(5);
const tasks = urls.map(url => limit(() => download(url)));
await Promise.all(tasks);

p-queue 实例化一个队列对象。 你将任务“添加”到队列中，队列负责调度。这更适合长运行的后台任务或需要动态添加任务的场景。

// p-queue: 实例模式
const queue = new PQueue({ concurrency: 5 });
urls.forEach(url => queue.add(() => download(url)));
await queue.onIdle();

p-throttle 返回一个限流函数。 类似于 p-limit，但它控制的是调用频率。你直接调用返回的函数，它会自动处理延迟。

// p-throttle: 限流函数模式
const throttledSave = pThrottle({ limit: 1, interval: 2000 })(saveToApi);
// 调用后，如果超限，返回的 Promise 会延迟 resolve
await throttledSave(data);

⚡ 优先级与调度策略

在处理混合重要性的任务时，调度策略至关重要。

p-limit 不支持优先级。 任务严格按照先进先出（FIFO）的顺序等待执行。你无法让一个紧急任务插队。

// p-limit: 无优先级支持
// 所有任务平等排队，无法干预顺序
const limit = pLimit(1);
limit(() => console.log('Task 1'));
limit(() => console.log('Task 2')); 
// 无法让 Task 2 先执行

p-queue 原生支持优先级。 你可以为每个任务分配优先级数值，高优先级的任务会优先获取执行名额。这对于处理用户交互触发的任务非常有用。

// p-queue: 支持优先级
const queue = new PQueue({ concurrency: 1 });
queue.add(() => console.log('Low'), { priority: 1 });
queue.add(() => console.log('High'), { priority: 10 });
// 'High' 会先于 'Low' 执行

p-throttle 不支持优先级。 它的核心是时间控制，调用顺序决定了执行顺序。它不管理任务队列的排序，只管理调用的时间间隔。

// p-throttle: 无优先级支持
// 严格按照调用顺序和时间间隔执行
const fn = pThrottle({ limit: 1, interval: 1000 })(task);
fn(); fn(); fn(); 
// 按调用顺序依次延迟执行

🛑 错误处理与队列状态

在批量处理中，如何处理错误和监控进度是工程化的关键。

p-limit 将错误抛回给调用者。 它本身不捕获错误，也不提供队列状态查询。如果某个任务失败，Promise.all 会立即拒绝（除非你自己在任务内部 catch）。

// p-limit: 错误透传
try {
  await Promise.all([limit(() => success()), limit(() => fail())]);
} catch (error) {
  // 任何一个失败都会捕获到这里
}

p-queue 提供丰富的状态监控。 你可以监听 error 事件，查询 size（排队数）和 pending（运行数）。它允许队列在任务失败后继续运行其他任务（取决于配置）。

// p-queue: 状态监控
const queue = new PQueue();
queue.on('error', err => console.error(err));
console.log(queue.size); // 排队数量
console.log(queue.pending); // 运行中数量

p-throttle 专注于调用控制。 它不管理任务队列的状态，只保证函数调用的频率。错误处理完全由被包装的函数决定。

// p-throttle: 错误由原函数处理
const fn = pThrottle({ limit: 1, interval: 1000 })(async () => {
  const res = await api.call();
  if (!res.ok) throw new Error('Failed');
  return res;
});
// 错误会作为 Promise rejection 返回

🌐 真实场景决策指南

场景 1：批量图片预加载

你需要加载 100 张图片，但浏览器同时打开太多连接会阻塞。

• ✅ 最佳选择：p-limit
• 理由：只需要限制并发数（如 6 个），不需要优先级，代码侵入性最小。

const limit = pLimit(6);
const images = urls.map(url => limit(() => loadImage(url)));
await Promise.all(images);

场景 2：后台数据同步服务

一个 Node.js 服务需要处理用户上传的任务，VIP 用户的任务需要优先处理。

• ✅ 最佳选择：p-queue
• 理由：需要优先级队列，且需要知道何时所有任务处理完毕（onIdle）以便关闭进程。

const queue = new PQueue({ concurrency: 5 });
tasks.forEach(task => {
  const priority = task.user.isVip ? 10 : 1;
  queue.add(() => process(task), { priority });
});
await queue.onIdle();
process.exit(0);

场景 3：调用受限的第三方 API

某 API 限制每分钟只能调用 60 次，否则会封禁。

• ✅ 最佳选择：p-throttle
• 理由：必须严格遵守时间窗口内的调用次数限制，并发数反而不是首要问题。

const callApi = pThrottle({ limit: 60, interval: 60000 })(fetchData);
dataIds.forEach(id => callApi(id));

📊 核心特性对比表

🤝 共同点：Promise 友好与轻量级

尽管功能不同，这三个库在设计哲学上有很多相似之处，这使得它们可以很好地协同工作。

1. 基于 Promise 的设计

• 所有库都原生支持 async/await。
• 返回的都是 Promise，可以无缝集成到现有的异步流程中。

// 三者都返回 Promise
await limit(() => task());
await queue.add(() => task());
await throttledFn();

2. 无依赖与轻量级

• 它们都旨在解决单一问题，不引入沉重的依赖。
• 适合在浏览器端和 Node.js 端同时使用。

// 都可以用于浏览器环境
// 不会像某些重型库那样增加显著的打包体积

3. 可组合性

• 它们可以组合使用。例如，用 p-throttle 限制频率，内部再用 p-limit 限制并发。

// 组合示例：每秒最多 10 次，每次并发 2 个
const throttle = pThrottle({ limit: 10, interval: 1000 });
const limit = pLimit(2);

const run = throttle(() => limit(() => task()));

💡 架构师建议

p-limit 是日常开发中最常用的工具 🛠️。如果你只是觉得 Promise.all 跑得太快，导致内存爆炸或 API 报错，先加一层 p-limit 通常就能解决问题。它简单、直观、无脑接入。

p-queue 是构建健壮后台服务的基石 🏗️。当你需要构建一个任务处理器、爬虫或需要保证任务顺序和优先级的系统时，它的队列管理能力是不可或缺的。特别是 onIdle 方法，对于编写自动化脚本非常有用。

p-throttle 是合规与保护的盾牌 🛡️。当面对外部约束（如 API Rate Limit）或需要平滑用户操作（如防止按钮狂点）时，它是最佳选择。注意，它和 p-limit 不同，它不控制“同时”，而是控制“频率”。

最终建议：在大多数前端数据获取场景中，p-limit 足以应付 90% 的需求。只有当你明确需要优先级调度或严格的时间限流时，才引入 p-queue 或 p-throttle。保持依赖精简，选择最匹配问题的工具。