In single-threaded, synchronous, non-recursive code, we can be sure that for any given function, there is never more than one invocation of it in progress at a time.

However, in the async/await world, the above no longer applies: while we're awaiting something during execution of async function f, it might be called again.

It occurred to me that, using event emitters and a queue, we could write a wrapper around an async function to guarantee that it never had more than one invocation at a time. Something like this:

const events = require('events')

function locked(async_fn) {
    const queue = [] // either actively running or waiting to run
    const omega = new events()

    omega.on('foo', () => {
        if (queue.length > 0) {
            queue[0].emit('bar')
        }
    })

    return function(...args) {
        return new Promise((resolve) => {
            const alpha = new events()
            queue.push(alpha)
            alpha.on('bar', async () => {
                resolve(await async_fn(...args))
                queue.shift()
                omega.emit('foo')
            })
            if (queue.length === 1) omega.emit('foo')
        })
    }
}

The idea is that if f is an async function then locked(f) is a function that does the same thing except that if f is called during execution of f, the new invocation doesn't begin until the first invocation returns.

I suspect my solution has lots of room for improvement, so I wonder: is there a better way of doing this? In fact, is there one already built into Node, or available via npm?

EDIT to show how this is used:

async function f() {
    console.log('f starts')
    await new Promise(resolve => setTimeout(resolve, 1000))
    console.log('f ends')
}

const g = locked(f)

for (let i = 0; i < 3; i++) {
    g()
}

Running this takes 3 seconds and we get the following output:

f starts
f ends
f starts
f ends
f starts
f ends

Whereas if we replace g() with f() in the for loop, execution takes 1 second and get the following:

f starts
f starts
f starts
f ends
f ends
f ends

(I realise this is a fairly minor question, and if it's not appropriate for stackoverflow I apologise, but I didn't know of a better place for it.)

In single-threaded, synchronous, non-recursive code, we can be sure that for any given function, there is never more than one invocation of it in progress at a time.

However, in the async/await world, the above no longer applies: while we're awaiting something during execution of async function f, it might be called again.

It occurred to me that, using event emitters and a queue, we could write a wrapper around an async function to guarantee that it never had more than one invocation at a time. Something like this:

const events = require('events')

function locked(async_fn) {
    const queue = [] // either actively running or waiting to run
    const omega = new events()

    omega.on('foo', () => {
        if (queue.length > 0) {
            queue[0].emit('bar')
        }
    })

    return function(...args) {
        return new Promise((resolve) => {
            const alpha = new events()
            queue.push(alpha)
            alpha.on('bar', async () => {
                resolve(await async_fn(...args))
                queue.shift()
                omega.emit('foo')
            })
            if (queue.length === 1) omega.emit('foo')
        })
    }
}

The idea is that if f is an async function then locked(f) is a function that does the same thing except that if f is called during execution of f, the new invocation doesn't begin until the first invocation returns.

I suspect my solution has lots of room for improvement, so I wonder: is there a better way of doing this? In fact, is there one already built into Node, or available via npm?

EDIT to show how this is used:

async function f() {
    console.log('f starts')
    await new Promise(resolve => setTimeout(resolve, 1000))
    console.log('f ends')
}

const g = locked(f)

for (let i = 0; i < 3; i++) {
    g()
}

Running this takes 3 seconds and we get the following output:

f starts
f ends
f starts
f ends
f starts
f ends

Whereas if we replace g() with f() in the for loop, execution takes 1 second and get the following:

f starts
f starts
f starts
f ends
f ends
f ends

(I realise this is a fairly minor question, and if it's not appropriate for stackoverflow I apologise, but I didn't know of a better place for it.)

• javascript
• node.js
• asynchronous

• async/await/promises nothing does with amount of calls? If you call function multiple times, then it will execute multiple times, that's it. Don't execute it multiple times as usually with normal non-async code? – Mevrael Commented Apr 27, 2018 at 18:08
• If this is working code and you're looking for feedback on ways it could be written better and you're willing to read the rules about how to post there, then this may be appropriate for codereview.stackexchange.. – jfriend00 Commented Apr 27, 2018 at 18:21
• async/await is just semantic sugar on top of promises. So you just need a promise queue such as npmjs./package/promise-queue – generalhenry Commented Apr 27, 2018 at 18:33
• @generalhenry That’s not true, async function is a sugar for sure but it is a auto-executed generator which returns a Promise, so it is on top of generator not promise. And I believe the OP was misunderstood some concepts, there are actually only one function is being executed at a time. – Leo Li Commented Apr 27, 2018 at 23:20
• @leo-li I understand that Node remains single-threaded even though I misused the word "execution" in my post. The phenomenon I'm trying to get at is something I never see discussed, so I don't know quite what terms to use, but I can demonstrate it ostensively using the example in my post: I'm talking about the fact that we can have another "f starts" before the first "f ends". So if "the world is inconsistent" in some sense between f starting and ending then we can't assume that the world is consistent when f starts. My function "locked" was designed to remedy this. – TheFlanCalculus Commented Feb 2, 2020 at 0:38

4 Answers 4

In case you stumble on this question, here is the code that does exactly what OP wanted:

const disallowConcurrency = (fn) => {
  let inprogressPromise = Promise.resolve()

  return (...args) => {
    inprogressPromise = inprogressPromise.then(() => fn(...args))
    
    return inprogressPromise
  }
}

Use it like this:

const someAsyncFunction = async (arg) => {
    await new Promise( res => setTimeout(res, 1000))
    console.log(arg)
}

const syncAsyncFunction = disallowConcurrency(someAsyncFunction)

syncAsyncFunction('I am called 1 second later')
syncAsyncFunction('I am called 2 seconds later')

You also might want to change function name to something more clear, because promises have actually nothing to do with concurrency.

Here is the decorator from my previous answers: (Live Demo)

function asyncBottleneck(fn, concurrency = 1) {
  const queue = [];
  let pending = 0;
  return async (...args) => {
    if (pending === concurrency) {
      await new Promise((resolve) => queue.push(resolve));
    }

    pending++;

    return fn(...args).then((value) => {
      pending--;
      queue.length && queue.shift()();
      return value;
    });
  };
}

Usage:

const task = asyncBottleneck(async () => {
  console.log("task started");
  await new Promise((resolve) => setTimeout(resolve, 1000));
  console.log("end");
});

task();
task();
task();
task();

Can I suggest my module here: https://www.npmjs./package/job-pipe

Basically if you have an async method:

const foo = async () => {...}

You create a pipe for it:

const pipe = createPipe({ maxQueueSize: Infinity })

Then you wrap your method like this:

const limitedFoo = pipe(foo)

An then you can do this kind of magic:

limitedFoo()
limitedFoo()
limitedFoo()
limitedFoo()
await limitedFoo()

Even though I am awaiting only for the last one, these functions will be executed one by one due to pipe restriction.

job-pipe allows bining multiple different methods into one pipe. It allows configuration where X number of parallel jobs are permitted. Also, you can monitor how many jobs are running and how many are queued at any time. You can also choose to abort them all if needed.

I know this is an old post but I hope it will help someone.

So, it'd be a hacky way to do it, but you could also just cache the fact the function was called.

let didRun = false;

async function runMeOnce() {
  if (didRun) return;
  didRun = true;

  ... do stuff
}

await runMeOnce():
await runMeOnce(); // will just return;

I'm sure there are much better solutions - but this would work with very little effort.