async函数中的并行与串行控制

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;
    }
}

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;
}

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;
}

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);
}

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);
        }
    });
}

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();