Strange async code behavior

Question

I have an unsolved JS behavior that I cannot understand. I'm running this code on node v8.4.0. I'm running this code twice.

First time with f1() second time with f2()

f2() the result is as expected. 'start' is printed first and then 'end'.

f1() the result is not as expected. 'end' is printed first and then 'start'.

Can someone please explain to me the result of the code below?

const fs = require('fs')

function f1() { return new Promise((resolve, reject) => { resolve() }) }

function f2() {
    return new Promise((resolve, reject) => {
        fs.readFile('/Users/adi/Downloads/profile.jpg', resolve)
    })
}

async function main() {

    setImmediate(() => { console.log('start') })
    await f1()
    console.log('end')
} 

main()

//f1 output:
end
start

//f2 output:
start
end

As far as I know, the result should be 'start' and then 'end'. What am I missing?

Answer 1

The queue with the resolved Promises will be check before the queue with setImmediate(() => { console.log('start') })

Because the f1 resolves immediately, both the callback of the setImmediate and the resolved Promise are added to the event queue at the same time, but at different stages. Resolved Promises have a higher priority then callbacks added with setImmediate

If you use process.nextTick then the callback will be added with an higher priority then setImmediate and start will be logged before end

function f1() { return new Promise((resolve, reject) => { resolve() }) }

async function main() {
    process.nextTick(() => { console.log('start') })
    setImmediate(() => { console.log('start') })
    await f1()
    console.log('end')
} 

main()

For f2 the reading of the file will involve a longer lasting async task so the setImmediat will be still called before.

Answer 2

So, in your f1() example, you have a race between setImmediate() and the .then() handler of an immediately resolved promise since both will be in the event queue at the time the next event is ready to be processed.

When both are ready to run, one runs before the other because of the internals of how different async things like setImmediate() and promises are coded to work in the node.js implementation of its event loop. Internal to the event loop in node.js, there is a sequence or priority for some different types of asynchronous operations and some go before others if all are waiting to go. It is possible, though difficult, to fully understand which goes before the others, but it is very complicated and it is mostly an implementation detail, not something fully documented by specification.

In this specific case, native promises in node.js use a microTasks queue (there are apparently a couple separate microTasks queues) and they are run before things like setImmediate(), timers and I/O events.

But, in general, it is best to not rely on fully understanding all that and, if you want one thing to happen before the other, don't allow it to be a race between the two inside of node.js. Just code it with your own code to force the sequence you want. This also makes your code more obvious and declarative what order you expect things to be processed in.

If I read your current code, I would think that you purposely set up a race between f1() and setImmediate() and did not care which one ran first because the code is not declarative and does not define a desired order.

For more info on the details of the internals of different types of async operations in the event loop, you can read these references:

Promise.resolve().then vs setImmediate vs nextTick

Promises, Next-Ticks and Immediates— NodeJS Event Loop Part 3

Promises wiggle their way between nextTick and setImmediate

Here's a quote from this last reference article:

Native promise handlers are executed on a microtask queue which is roughly the same as nextTick, so they run before everything else. Pure javascript [promise] implementations should use nextTick for scheduling.

---

For your f2() example, it's probably just that fs.readFile() takes some finite amount of time so f2() does not resolve immediately and thus isn't ready to run at the same time that setImmediate() is so the setImmediate() runs before f2() resolves.

Answer 3

It's works like this, because Promise is a microtask. Microtasks are executed at the end of call stack, before macrotasks. You can read more here