Thenjs有没有Nodejs的async.parallelLimit对应的用法？

Thenjs有没有Nodejs的async.parallelLimit对应的用法？

async.parallelLimit(tasks, limit, [callback]) 用limit控制并行执行任务的最大个数，Thenjs是否有对应的用法？

2 回复

当然可以。Thenjs 是一个基于 Promise 的库，它允许你以链式调用的方式处理异步操作。虽然 Thenjs 没有直接提供类似于 async.parallelLimit 的功能，但你可以通过组合其他 Promise 方法来实现类似的功能。

下面是一个示例代码，展示如何使用 Thenjs 实现类似于 async.parallelLimit 的效果：

const Then = require('thenjs');

// 定义一些异步任务
function asyncTask(taskId) {
    return new Then(function (deferred) {
        setTimeout(() => {
            console.log(`Task ${taskId} completed`);
            deferred.resolve(`Result of Task ${taskId}`);
        }, Math.random() * 1000);
    });
}

// 创建任务数组
const tasks = Array.from({ length: 10 }, (_, i) => asyncTask(i + 1));

// 限制并行执行的任务数量
const limit = 3;

// 使用 Promise.all 和 slice 来实现并行限制
function parallelLimit(tasks, limit) {
    let results = [];
    const runningTasks = [];

    function runNextTask() {
        if (tasks.length === 0) return;
        
        const task = tasks.shift();
        runningTasks.push(task);

        task.then(result => {
            results.push(result);
            const index = runningTasks.indexOf(task);
            if (index !== -1) {
                runningTasks.splice(index, 1);
            }
            runNextTask();
        }).catch(err => {
            console.error(err);
            const index = runningTasks.indexOf(task);
            if (index !== -1) {
                runningTasks.splice(index, 1);
            }
            runNextTask();
        });
    }

    for (let i = 0; i < limit && i < tasks.length; i++) {
        runNextTask();
    }

    return new Then((deferred) => {
        deferred.resolve(results);
    });
}

parallelLimit(tasks, limit).then(results => {
    console.log('All tasks completed:', results);
});

解释

  1. 定义任务：我们定义了一个简单的异步任务函数 asyncTask，它返回一个 Thenjs Promise，并模拟了一些延迟。
  2. 创建任务数组：我们创建了10个这样的任务。
  3. 限制并行任务数量：我们定义了一个 parallelLimit 函数，它接受任务数组和一个限制值。
  4. 运行任务：runNextTask 函数负责从任务数组中取出任务并执行。当一个任务完成时，它会检查是否还有任务可以运行，并继续执行。
  5. 最终结果：所有任务完成后，我们打印出结果。

这样，你就可以用 Thenjs 实现类似于 async.parallelLimit 的功能了。


Thenjs 并没有直接提供类似于 async.parallelLimit 的功能。不过，你可以使用 Promise 和一些辅助函数来实现类似的效果。

示例代码

const Promise = require('bluebird');

function runTasksInParallelLimit(tasks, limit) {
    const results = [];
    let pendingTasks = tasks.length;
    let currentIndex = 0;

    return new Promise((resolve, reject) => {
        function runNextTask() {
            if (currentIndex >= tasks.length || pendingTasks === 0) {
                resolve(results);
                return;
            }

            if (pendingTasks < limit) {
                pendingTasks++;
                const task = tasks[currentIndex++];
                Promise.resolve(task())
                    .then(result => {
                        results.push(result);
                        pendingTasks--;
                        runNextTask();
                    })
                    .catch(reject);
            } else {
                setTimeout(runNextTask, 0);
            }
        }

        runNextTask();
    });
}

// 示例用法
const tasks = [
    () => new Promise(resolve => setTimeout(() => resolve('Task 1'), 500)),
    () => new Promise(resolve => setTimeout(() => resolve('Task 2'), 200)),
    () => new Promise(resolve => setTimeout(() => resolve('Task 3'), 300)),
    () => new Promise(resolve => setTimeout(() => resolve('Task 4'), 400))
];

runTasksInParallelLimit(tasks, 2)
    .then(results => console.log(results))
    .catch(error => console.error(error));

解释

  • runTasksInParallelLimit 函数接受一个任务数组和一个限制并行执行的任务数量。
  • 使用 Promise 来处理异步任务，并通过递归方式控制任务的并行度。
  • 当当前正在运行的任务数小于限制时，继续执行下一个任务；否则，通过 setTimeout 将控制权交还给事件循环，以便其他任务可以完成。

这样，你就可以实现类似于 async.parallelLimit 的功能。

回到顶部