throat

What is throat?

The 'throat' npm package is a utility for limiting the number of concurrent asynchronous operations. It is particularly useful when you need to control the rate of operations to avoid overwhelming resources or hitting rate limits.

What are throat's main functionalities?

Limit Concurrent Promises

This feature allows you to limit the number of concurrent promises. In this example, only 2 tasks will run concurrently.

const throat = require('throat')(2);

const tasks = [
  () => new Promise(resolve => setTimeout(() => resolve('Task 1'), 1000)),
  () => new Promise(resolve => setTimeout(() => resolve('Task 2'), 500)),
  () => new Promise(resolve => setTimeout(() => resolve('Task 3'), 300)),
  () => new Promise(resolve => setTimeout(() => resolve('Task 4'), 200))
];

Promise.all(tasks.map(throat(task => task()))).then(results => {
  console.log(results); // ['Task 1', 'Task 2', 'Task 3', 'Task 4']
});

Limit Concurrent Function Calls

This feature allows you to limit the number of concurrent function calls. In this example, only 1 task will run at a time.

const throat = require('throat')(1);

const task = (name, delay) => () => new Promise(resolve => setTimeout(() => resolve(name), delay));

const tasks = [
  task('Task 1', 1000),
  task('Task 2', 500),
  task('Task 3', 300),
  task('Task 4', 200)
];

Promise.all(tasks.map(throat(task => task()))).then(results => {
  console.log(results); // ['Task 1', 'Task 2', 'Task 3', 'Task 4']
});

Other packages similar to throat

p-limit

The 'p-limit' package provides similar functionality by limiting the number of concurrent promises. It offers a more modern API and is often used in conjunction with other promise utilities from the 'p-*' family of packages.

async

The 'async' package is a comprehensive utility library for asynchronous operations. It includes a 'queue' function that can limit the number of concurrent tasks, among many other features. It is more feature-rich but also more complex than 'throat'.

promise-limit

The 'promise-limit' package is another alternative for limiting the number of concurrent promises. It is lightweight and straightforward, similar to 'throat', but with a slightly different API.

README

throat

Throttle the parallelism of an asynchronous, promise returning, function / functions. This has special utility when you set the concurrency to 1. That way you get a mutually exclusive lock.

Installation

npm install throat

API

throat(concurrency)

This returns a function that acts a bit like a lock (exactly as a lock if concurrency is 1).

Example, only 2 of the following functions will execute at any one time:

var throat = require('throat')(2)

var resA = throat(function () {
  //async stuff
  return promise
})
var resA = throat(function () {
  //async stuff
  return promise
})
var resA = throat(function () {
  //async stuff
  return promise
})
var resA = throat(function () {
  //async stuff
  return promise
})
var resA = throat(function () {
  //async stuff
  return promise
})

throat(concurrency, worker)

This returns a function that is an exact copy of worker except that it will only execute up to concurrency times in parallel before further requests are queued:

var input = ['fileA.txt', 'fileB.txt', 'fileC.txt', 'fileD.txt']
var data = Promise.all(input.map(throat(2, function (fileName) {
  return readFile(fileName)
})))

Only 2 files will be read at a time, sometimes limiting parallelism in this way can improve scalability.

License

MIT