Async-Concurrency-Pool

Node.js pool for limiting the number of asynchronous tasks that run concurrently.

Install

npm install async-concurrency-pool

Why?

Because I needed a simple mechanism to run an arbitrary number of tasks concurrently and didn't want to install a library with a bunch of features I don't need. It's written in typescript and the NPM package installs with the declaration files. It is intended to be used in node.js and uses native promises.

Usage

I mostly use this as a base class and as a result it is intentionally bare bones. A factory function createAsyncPool, the class itself AsyncPool and a helper class I use for testing LoopStats is exposed. ragent-pool is an example of a module that extends AsyncPool and includes implementation specific logic for how/when to return the agent to the pool.

import { createAsyncPool } from 'async-concurrency-pool';


class FooAgent {
  doSomethingAsync(n) {
        return new Promise((res)=>{
          setTimeout(()=>{
            res(n);
          }, 200);
        });
      }     
}
// this will be called with no arguments
// when a new instance of your agent is needed 
function agentFactory(){
  return new FooAgent();
}


async function doSomethingWithAgentPool() {
  const maxAgents = 2;
  const agentPool = createAsyncPool(agentFactory, maxAgents);
  
  let cnt = 0;
  
  
  /**
  *  The following loop will execute .doSomethingAsync 
  *  in parallel UNTIL `maxAgents` has been reached. 
  *  At that point all future calls to .doSomethingAsync will
  *  essentially execute in series moving to the 
  *  next iteration when the fastest pending async
  *  task in the pool completes
  **/
  
  for await(const agent of agentPool){
    
    // it is necessary to implement your own logic for 
    // breaking from the loop as the pool will loop indefinitely
    cnt += 1;
    if (cnt > 10){
      break;
    }
    
    // when the agent has completed the task you must manually call either
    // agentPool.add(agent) OR agentPool.remove(agent)
    // failure to do so will result in the loop pausing 
    // indefinitely once maxAgents has been reached as the 
    // pool is intentionally ignorant about when your 
    // agent has completed it's  work.
    agent.doSomethingAsync(cnt)
    .then((n)=>{
      // return the agent to the pool to be reused later
      agentPool.add(agent);
      return n;
    })
    .catch((err)=>{
      // remove the agent from the pool so it will not be used 
      agentPool.remove(agent);
      return err;
    })

    // NOTE: using .then .catch .finally on the agent 
    // allows tasks to be run in parallel 
    // using await agent.doSomethingAsync(cnt) would
    // result in everything being run in  series    
  }
}

Tests

npm run test