async函数并行与串行执行方法

小伙伴们对文章编程感兴趣吗？是否正在学习相关知识点？如果是，那么本文《async函数并行与串行执行技巧》，就很适合你，本篇文章讲解的知识点主要包括。在之后的文章中也会多多分享相关知识点，希望对大家的知识积累有所帮助！

并行处理适用于无依赖任务，使用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 密集型任务（如网络请求）时非常实用，既能利用并行优势，又能避免资源枯竭。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。