auto-reset-event

This package mimic the behavior of AutoResetEvent of C#, an acquire-release one semantic.

Background

Although JavaScript is single-threaded, one might want to limit number of concurrent asynchronous operations. For example, a task that requires multiple asynchronous steps to complete can use this package to limit its concurrency.

How to use

Run npm install auto-reset-event.

Code snippets

import createAutoResetEvent from 'auto-reset-event';
 
// Create an acquire-release queue
const acquire = createAutoResetEvent();
 
// Acquire a single lock, this function will not be resolved until the lock is acquired
const release = await acquire();
 
// Do the non-parallelized asynchronous work
 
// Release the lock
release();

Full sample

import createAutoResetEvent from 'auto-reset-event';
import delay from 'delay';
 
async function main() {
  const acquire = createAutoResetEvent();
 
  await Promise.all([
    (async () => {
      const release = await acquire();
 
      console.log('You will see this first.');
      await delay(1000);
 
      release();
    })(),
    (async () => {
      const release = await acquire();
 
      console.log('You will see this after a second.');
      await delay(1000);
 
      release();
    })(),
  ]);
 
  console.log('You will see this last, after two seconds.');
}
 
main().catch(err => console.error(err));

Samples

auto-reset-event can be used to limit concurrency for asynchronous operations.

Slowing down web traffic for debugging purpose

We can use auto-reset-event to easily slow down concurrent requests by limiting its concurrency and serving rate. In this sample, we slowed down serving static content by serving one request every second.

import { createServer } from 'restify';
import createAutoResetEvent from 'auto-reset-event';
import delay from 'delay';
import serveHandler from 'serve-handler';
 
const server = createServer();
const acquireSlowLock = createAutoResetEvent();
 
server.get('/public/*', async (req, res) => {
  // If ?slow is added to the URL, we will slow it down by serving one request every second
  if ('slow' in req.query) {
    // Make sure it is not cached, so we can replay the slow behavior easily
    res.noCache();
 
    const release = await acquireSlowLock();
 
    await delay(1000);
    release();
  }
 
  await serveHandler(req, res, { path: join(__dirname, './public') });
});
 
server.listen(process.env.PORT || 80);

Contributions

Like us? Star us.

Want to make it better? File us an issue.

Don't like something you see? Submit a pull request.