pend

What is pend?

The pend npm package is designed to manage and limit the concurrency of asynchronous operations in Node.js applications. It provides a simple API to queue tasks and control how many of them are executed in parallel, making it easier to manage resources and improve the performance of applications that perform a lot of asynchronous operations, such as file I/O or network requests.

What are pend's main functionalities?

Limiting concurrency of asynchronous operations

This code sample demonstrates how to use pend to limit the concurrency of asynchronous operations. It creates a new Pend instance, sets a concurrency limit, and then queues several asynchronous operations. Pend ensures that only a specified number of operations run in parallel, and provides a callback for when all operations are completed.

const Pend = require('pend');

const pend = new Pend();
pend.max = 2; // Limit to 2 concurrent operations

function asyncOperation(callback) {
  setTimeout(() => {
    console.log('Operation completed');
    callback();
  }, 1000);
}

for (let i = 0; i < 5; i++) {
  pend.go((cb) => {
    asyncOperation(cb);
  });
}

pend.wait(() => {
  console.log('All operations completed');
});

Other packages similar to pend

async

The async package is a comprehensive collection of utility functions for working with asynchronous JavaScript. It includes features for controlling the flow of asynchronous operations, such as limiting concurrency, similar to pend. However, async offers a broader range of functionalities beyond concurrency control, making it more versatile but also more complex.

p-limit

p-limit is a lightweight package specifically designed to limit the concurrency of promise-returning & async functions. It is very similar to pend in its purpose but works with Promises instead of callbacks, making it more suitable for modern asynchronous patterns in JavaScript.

README

Pend

Dead-simple optimistic async helper.

Usage

var Pend = require('pend');
var pend = new Pend();
pend.max = 10; // defaults to Infinity
setTimeout(pend.hold(), 1000); // pend.wait will have to wait for this hold to finish
pend.go(function(cb) {
  console.log("this function is immediately executed");
  setTimeout(function() {
    console.log("calling cb 1");
    cb();
  }, 500);
});
pend.go(function(cb) {
  console.log("this function is also immediately executed");
  setTimeout(function() {
    console.log("calling cb 2");
    cb();
  }, 1000);
});
pend.wait(function(err) {
  console.log("this is excuted when the first 2 have returned.");
  console.log("err is a possible error in the standard callback style.");
});

Output:

this function is immediately executed
this function is also immediately executed
calling cb 1
calling cb 2
this is excuted when the first 2 have returned.
err is a possible error in the standard callback style.