有效管理JavaScript中并发异步操作：Promise.all的应用实践

理解异步操作与常见陷阱

在现代javascript开发中，async/await语法极大地简化了异步代码的编写，使其看起来更像同步代码，提高了可读性。然而，在处理多个并发异步操作时，如果不理解底层机制，仍然容易遇到意想不到的问题。

一个常见的陷阱是尝试在Array.prototype.forEach循环内部直接使用async/await来执行异步任务，并期望外部函数能等待所有这些任务完成。例如，考虑以下场景：

// 原始的、存在问题的代码模式
export async function consumer(event, context) {
    event.Records.forEach(async (record) => {
        const body = JSON.parse(record.body);
        // api_url在这里需要正确初始化和定义
        // 假设 api_url 是一个 URL 对象，并且已经定义
        const api_url = new URL("https://example.com/api"); // 示例初始化
        api_url.searchParams.append("url", body.url);

        // 调用异步函数
        await callPSI(api_url.href);
    });
    // 问题：consumer函数不会等待 forEach 内部的所有 await 完成就可能返回
}

export const callPSI = async (url) => {
    // 原始代码中这里有一个硬编码的url，这会覆盖传入的url参数
    // const url = "https://jsonmock.hackerrank.com/api/movies"; // 这是一个潜在的bug

    // 原始代码混合了 async/await 和 .then()
    fetch(url).then(res => {
        console.log("response: ", res);
        return res.json();
    }).then(data => {
        console.log('data: ', data);
    });
    // 问题：callPSI 函数本身没有 await fetch，也没有返回 Promise
    // 导致外部 await callPSI 无法真正等待 fetch 完成
};

上述代码存在两个主要问题：

1. forEach的同步性：forEach方法本身是同步的。它会遍历数组中的每个元素，并为每个元素执行提供的回调函数。即使回调函数被标记为async并包含await表达式，forEach也不会等待这些异步操作完成。它只是启动了这些异步任务，然后立即继续执行下一个元素或完成循环。这意味着consumer函数可能会在所有callPSI调用完成之前就结束，特别是在AWS Lambda这样的无服务器环境中，这会导致函数提前退出，请求得不到处理，日志缺失等问题。
2. 异步模式混用与Promise链断裂：在callPSI函数中，虽然函数被标记为async，但内部却使用了fetch().then().then()的链式调用，并且没有await这些链式调用的结果，也没有显式返回一个Promise。这使得外部的await callPSI(api_url.href)实际上并没有等待fetch操作完成。

解决方案：利用 Promise.all 实现并发控制

要解决上述问题，我们需要一种机制来确保所有并发的异步操作都已完成，然后再继续执行后续逻辑。Promise.all正是为此而设计的。它接收一个Promise数组作为输入，并返回一个新的Promise，只有当输入数组中的所有Promise都成功解决后，这个新的Promise才会解决。

结合Array.prototype.map，我们可以将数组中的每个元素转换为一个异步操作（一个Promise），然后将这些Promises收集起来传递给Promise.all。

立即学习“Java免费学习笔记（深入）”；

AppMall应用商店

AI应用商店，提供即时交付、按需付费的人工智能应用服务

56

查看详情

以下是经过重构和优化的代码示例：

// 假设 api_url 是一个全局或可访问的 URL 对象
// 例如：const api_url = new URL("https://your-base-api.com");

export async function consumer(event, context) {
    // 使用 Promise.all 和 map 来确保所有异步操作完成
    await Promise.all(
        event.Records.map(async (record) => {
            const body = JSON.parse(record.body);
            // 确保 api_url 在这里被正确初始化或引用
            const apiUrlInstance = new URL("https://example.com/api"); // 示例：每次循环创建一个新实例或确保其可变
            apiUrlInstance.searchParams.append("url", body.url);

            try {
                // 直接在这里执行 fetch 操作，并使用 async/await 模式
                const resp = await fetch(apiUrlInstance.href);
                if (!resp.ok) {
                    throw new Error(`HTTP error! status: ${resp.status}`);
                }
                const json = await resp.json();
                console.log("Fetched data:", json);
                // 这里可以进一步处理 json 数据
            } catch (error) {
                console.error("Error processing record:", record, "Error:", error);
                // 根据需要处理错误，例如记录到日志系统，或重新入队
            }
        })
    );
    // 至此，所有 record 的异步处理都已完成
    console.log("All records processed.");
}

// callPSI 函数不再需要，其逻辑已内联到 consumer 中
// 如果 callPSI 有其他独立用途，可以保留并确保其内部正确使用 async/await 并返回 Promise

代码解析：

1. event.Records.map(async (record) => { ... }):
   • map方法遍历event.Records数组中的每个元素。
   • 对于每个record，它执行一个async回调函数。这个async函数会执行异步操作（例如fetch），并隐式地返回一个Promise。
   • map最终会返回一个由这些Promise组成的新数组。
2. await Promise.all(...):
   • Promise.all接收map返回的Promise数组。
   • await关键字确保consumer函数会暂停执行，直到Promise.all返回的Promise解决。
   • 只有当数组中的所有fetch操作都成功完成并解析其JSON数据后，Promise.all才会解决。
3. 内联fetch与async/await:
   • 原callPSI的逻辑被直接整合到map的回调函数中。
   • await fetch(apiUrlInstance.href)确保了HTTP请求发送并等待响应。
   • await resp.json()确保了响应体被完全解析为JSON。
   • 这种模式保持了异步操作的清晰和一致性。
4. 健壮的错误处理:
   • try...catch块被引入以捕获在fetch或JSON解析过程中可能发生的任何错误（例如网络问题、API错误响应、JSON解析失败等）。
   • 在生产环境中，应将错误记录到适当的日志服务（如CloudWatch Logs），并考虑错误处理策略（如重试、死信队列等）。

关键考量与最佳实践

• forEach 与 map 的选择：
  • 当你的异步操作需要并发执行，并且你关心所有操作是否都完成时，始终使用Array.prototype.map结合Promise.all。
  • forEach适用于不需要等待内部异步操作完成的场景，例如仅仅触发一个“消防即忘”（fire-and-forget）的异步任务。
• 一致的异步模式：
  • 在项目或模块中，尽量保持async/await或.then().catch()的一种异步模式。避免混用，因为这会增加代码的复杂性和出错的可能性。
  • async/await通常被认为是更现代、更易读的方式。
• 错误处理：
  • 在任何异步操作中，try...catch都是必不可少的。它能捕获运行时错误，防止应用程序崩溃，并允许你优雅地处理异常情况。
  • 对于Promise.all，如果其中任何一个Promise被拒绝（即发生错误），Promise.all返回的Promise会立即拒绝，并返回第一个被拒绝的Promise的错误。如果需要即使部分Promise失败也能获取所有Promise的结果，可以考虑使用Promise.allSettled()（ES2020）。
• Lambda环境下的注意事项：
  • AWS Lambda函数在所有异步操作完成后或达到超时时间后才会停止执行。使用await Promise.all可以确保Lambda函数在所有fetch操作完成后才退出，从而避免数据丢失或处理不完整的问题。
  • 注意Lambda的内存和CPU限制，大量的并发fetch请求可能会消耗大量资源。

总结

正确处理JavaScript中的并发异步操作是编写健壮、高效代码的关键，尤其是在无服务器架构中。通过理解forEach的同步特性，并熟练运用Promise.all与Array.prototype.map的组合，我们可以有效地管理多个异步任务，确保它们按预期完成，并提高应用程序的可靠性。同时，采用一致的async/await模式和完善的错误处理机制，将使你的代码更易于维护和调试。

以上就是有效管理JavaScript中并发异步操作：Promise.all的应用实践的详细内容，更多请关注php中文网其它相关文章！