并行处理适用于无依赖任务，使用promise.all()或promise.allsettled()实现；串行处理用于需顺序执行的场景，可通过循环或reduce链式调用完成；有限并发控制可借助任务队列和并发计数器平衡效率与资源占用。
在异步函数的世界里，并行与串行控制是我们日常编码中不可或缺的考量。简单来说，并行就是让多个任务同时跑起来，争取最快的总完成时间；而串行则是让任务一个接一个地执行，确保每一步都按序完成，这通常是为了资源管理、依赖关系或者避免某些副作用。选择哪种方式，往往取决于你手头任务的特性：是追求极致的吞吐量，还是需要严格的执行顺序和资源约束。
解决方案
处理 async 函数中的并行与串行，核心在于对 Promise 的运用。
实现并行：
最直接的方式是利用 Promise.all()。当你有一组相互独立、没有先后依赖的异步任务时，把它们包装成 Promise 数组，然后丢给 Promise.all()。它会等待所有 Promise 都成功解决后，返回一个包含所有结果的数组。这就像你同时启动了多台机器，它们各自干活，最后你等着所有机器都出结果。
async function fetchMultipleDataParallel() { const urls = ['/api/data1', '/api/data2', '/api/data3']; try { // 假设 fetchData 是一个返回 Promise 的异步函数 const results = await Promise.all(urls.map(url => fetchData(url))); console.log('所有数据并行获取完成:', results); return results; } catch (error) { console.error('并行获取数据时发生错误:', error); // Promise.all 的一个特点是，只要有一个 Promise 失败，它就会立即拒绝 throw error; }}
如果你不关心所有任务是否都成功，或者想知道每个任务的最终状态（成功还是失败），Promise.allSettled() 是更好的选择。它会等待所有 Promise 都“落定”（settled，即成功或失败），然后返回一个包含每个 Promise 状态和结果（或原因）的对象数组。这在处理一组可能失败的任务时特别有用，你不想因为一个任务的失败而中断整个流程。
实现串行：
最直观的串行控制就是使用 await 关键字在一个循环中。当你需要确保前一个异步操作完成后，下一个才能开始时，这种方式非常适用。
async function processTasksSequentially() { const taskIds = [101, 102, 103]; const results = []; for (const id of taskIds) { try { // 假设 processTask 是一个异步函数 const result = await processTask(id); // 等待当前任务完成 results.push(result); console.log(`任务 ${id} 完成，结果:`, result); } catch (error) { console.error(`任务 ${id} 失败:`, error); // 可以选择继续或中断 } } console.log('所有任务串行处理完成:', results); return results;}
另一种优雅的串行方式是使用 Array.prototype.reduce 来链式执行 Promise。这在处理一系列相互依赖的异步操作时尤其强大。
async function chainDependentOperations() { const operations = [ async (data) => { /* operation 1 */ return data + 1; }, async (data) => { /* operation 2 */ return data * 2; }, async (data) => { /* operation 3 */ return data - 5; } ]; const finalResult = await operations.reduce(async (previousPromise, currentOperation) => { const previousResult = await previousPromise; // 等待上一个操作完成 return currentOperation(previousResult); // 执行当前操作并返回新的 Promise }, Promise.resolve(0)); // 初始值，可以是任何 Promise.resolve(initialValue) console.log('链式操作最终结果:', finalResult); // 预计输出 (0+1)*2-5 = -3 return finalResult;}
这种 reduce 的用法，将上一个操作的结果作为下一个操作的输入，非常适合数据流动的场景。
异步任务何时应该并行处理？
这是一个常见的决策点。我的经验是，当你的异步任务之间没有任何数据依赖或执行顺序上的强制要求时，就应该考虑并行。想象一下，你要从三个不同的微服务拉取数据，这三份数据各自独立，谁先回来都没关系，只要最后都拿到了就行。这时候，用 Promise.all 去并行请求是最高效的。
另一个考虑是用户体验。如果你的应用需要加载多张图片、多个API数据来填充页面，让它们并行加载可以显著减少用户的等待时间，提升感知性能。用户通常不愿意等待一个又一个的请求完成。
然而，并行并非总是万能药。它会占用更多的系统资源，比如网络带宽、CPU或内存。如果你在短时间内发起数百个并行请求，可能会导致服务器过载、浏览器崩溃，或者被API限流。所以，并行更多的是一种优化策略，而不是无脑应用。你需要评估任务的性质、可用的资源以及潜在的风险。
如何在并行任务中优雅地处理错误和部分成功？
并行任务的错误处理是个棘手的问题。Promise.all() 的“全有或全无”特性，即一旦其中一个 Promise 拒绝，整个 Promise.all 就会立即拒绝，并且不会等待其他仍在执行的 Promise。这对于一些严格要求所有任务都成功的场景很合适，但很多时候我们希望即使有任务失败，也能知道哪些失败了，哪些成功了，并继续处理成功的部分。
这时候，Promise.allSettled() 就派上用场了。它返回的结果是一个数组，每个元素都是一个对象，包含 status（’fulfilled’ 或 ‘rejected’）和 value（成功时的结果）或 reason（失败时的错误）。
async function fetchWithPartialSuccess() { const urls = [ '/api/good-data', '/api/bad-data-will-fail', '/api/another-good-data' ]; const results = await Promise.allSettled(urls.map(url => fetchData(url))); results.forEach((result, index) => { if (result.status === 'fulfilled') { console.log(`URL ${urls[index]} 成功:`, result.value); // 可以继续处理成功的数据 } else { console.error(`URL ${urls[index]} 失败:`, result.reason); // 记录错误，或进行回滚等操作 } }); // 你甚至可以过滤出成功的结果 const successfulResults = results .filter(r => r.status === 'fulfilled') .map(r => r.value); console.log('成功获取的数据:', successfulResults); // 或者找出所有失败的原因 const failedReasons = results .filter(r => r.status === 'rejected') .map(r => r.reason); console.log('失败的原因:', failedReasons);}
通过 Promise.allSettled()，你可以对每个任务的最终状态进行细粒度的控制和处理，而不必因为一个失败而放弃整个批次。
另一种策略是在映射每个 Promise 时，就用 try...catch 包裹住，让每个单独的 Promise 总是解决（fulfilled），即使内部发生错误。这样 Promise.all() 就能正常运行，你会在结果数组中得到错误对象而不是实际数据。
async function fetchAndHandleErrorsIndividually() { const urls = ['/api/data1', '/api/data-fail', '/api/data3']; const promises = urls.map(async (url) => { try { const data = await fetchData(url); return { status: 'success', data }; } catch (error) { return { status: 'error', error: error.message, url }; } }); const results = await Promise.all(promises); // 这里的 Promise.all 不会拒绝 results.forEach(item => { if (item.status === 'success') { console.log('成功获取:', item.data); } else { console.error(`从 ${item.url} 获取失败:`, item.error); } });}
这种方式的优点是，Promise.all 不会因为单个错误而中断，但你需要自己在返回的数据结构中处理错误信息。
如何实现对异步任务的有限并发控制？
有时候，我们既想利用并行提升效率，又不想一次性启动太多任务导致资源耗尽或被限流。这时，有限并发控制就显得尤为重要。这就像你有一条生产线，可以同时处理3个订单，但不能更多。
实现有限并发的一种常见模式是使用一个“任务队列”和“工人池”。你可以维护一个正在执行的任务计数器，当达到最大并发数时，新的任务就进入等待队列。当有任务完成时，就从队列中取出下一个任务开始执行。
下面是一个简化的实现思路：
class ConcurrencyLimiter { constructor(limit) { this.limit = limit; // 最大并发数 this.running = 0; // 当前正在运行的任务数 this.queue = []; // 等待执行的任务队列 } /** * 添加一个异步任务到队列 * @param {Function} taskFn - 返回 Promise 的异步函数 * @returns {Promise} - 任务执行结果的 Promise */ add(taskFn) { return new Promise((resolve, reject) => { this.queue.push({ taskFn, resolve, reject }); this.runNext(); }); } async runNext() { if (this.running >= this.limit || this.queue.length === 0) { return; // 达到并发上限或没有任务了 } this.running++; const { taskFn, resolve, reject } = this.queue.shift(); // 取出队列中的第一个任务 try { const result = await taskFn(); // 执行任务 resolve(result); } catch (error) { reject(error); } finally { this.running--; // 任务完成，无论成功失败，减少运行计数 this.runNext(); // 尝试运行下一个任务 } }}// 示例用法：async function simulateTask(id, duration) { console.log(`任务 ${id} 开始, 预计耗时 ${duration}ms`); return new Promise(resolve => setTimeout(() => { console.log(`任务 ${id} 完成`); resolve(`任务 ${id} 的结果`); }, duration));}async function runLimitedConcurrency() { const limiter = new ConcurrencyLimiter(2); // 最大并发数设为2 const tasks = [ limiter.add(() => simulateTask(1, 1000)), limiter.add(() => simulateTask(2, 500)), limiter.add(() => simulateTask(3, 1200)), limiter.add(() => simulateTask(4, 800)), limiter.add(() => simulateTask(5, 600)), ]; console.log('所有任务已提交'); const results = await Promise.all(tasks); // 等待所有任务完成 console.log('所有任务（有限并发）完成:', results);}runLimitedConcurrency();
这个 ConcurrencyLimiter 类就是一种简单的有限并发控制机制。它确保了在任何给定时间点，最多只有 limit 个任务在同时执行。当一个任务完成时，它会立即检查队列中是否有等待的任务，并启动下一个。这在处理大量 I/O 密集型任务（如网络请求）时非常实用，既能利用并行优势，又能避免资源枯竭。
以上就是async函数中的并行与串行控制的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1510248.html
微信扫一扫 
支付宝扫一扫 
