await-semaphore

Awaitable semaphore/mutex

A semaphore implementation using ES6 promises and supporting 3 styles:

• async/await style (needs typescript)
• thunk style (automatic acquire/release)
• promise style

Also includes Mutex as a convenience for new Semaphore(1).

API

new Semaphore(count: number)

Create a new semaphore with the given count.

1import {Semaphore} from 'await-semaphore';
2
3var semaphore = new Semaphore(10);

semaphore.acquire(): Promise<() => void>

Acquire the semaphore and returns a promise for the release function. Be sure to handle release for exception case.

1semaphore.acquire()
2.then(release => {
3    //critical section...
4    doSomething()
5    .then(res => {
6        //...
7        release();
8    })
9    .catch(err => {
10        //...
11        release();
12    });
13});

semaphore.use(thunk: () => Promise): Promise

Alternate method for using the semaphore by providing a thunk. This automatically handles acquire/release.

1semaphore.use(() => {
2    //critical section...
3});

new Mutex()

An alias for new Semaphore(1). Mutex has the same methods as Semaphore.

1import {Mutex} from 'await-semaphore';
2
3var mutex = new Mutex();

Examples

Create a version of fetch() with concurrency limited to 10.

async/await style (typescript)

1var semaphore = new Semaphore(10);
2
3async function niceFetch(url) {
4    var release = await semaphore.acquire();
5    var result = await fetch(url);
6    release();
7    return result;
8}

thunk style (javascript)

1var semaphore = new Semaphore(10);
2
3function niceFetch(url) {
4    return semaphore.use(() => fetch(url));
5}

promise style (javascript)

1var semaphore = new Semaphore(10);
2
3function niceFetch(url) {
4    return semaphore.acquire()
5    .then(release => {
6        return fetch(url)
7        .then(result => {
8            release();
9            return result;
10        });
11    });
12}