Node exits without error and doesn’t await promise (Event callback)

by

This question is basically: how does node decide whether to exit the event loop or go around again?

Basically node keeps a reference count of scheduled async requests — setTimeouts, network requests, etc.. Each time one is scheduled, that count increases, and each time one is finished, the count decreases. If you arrive at the end of an event loop cycle and that reference count is zero node exits.

Simply creating a promise or event emitter does not increase the reference count — creating these objects isn’t actually an async operation. For example, this promise’s state will always be pending but the process exits right away:

const p = new Promise( resolve => {
    if(false) resolve()
})

p.then(console.log)

In the same vein this also exits after creating the emitter and registering a listener:

const ev = new EventEmitter()
ev.on("event", (e) => console.log("event:", e))

If you expect Node to wait on an event that is never scheduled, then you may be working under the idea that Node doesn’t know whether there are future events possible, but it does because it keeps a count every time one is scheduled.

So consider this small alteration:

const ev = new EventEmitter()
ev.on("event", (e) => console.log("event:", e))

const timer = setTimeout(() => ev.emit("event", "fired!"), 1000)
// ref count is not zero, event loop will go again. 
// after timer fires ref count goes back to zero and node exits

As a side note, you can remove the reference to the timer with: timeout.unref(). This, unlike the previous example, will exit immediately:

const ev = new EventEmitter()
ev.on("event", (e) => console.log("event:", e))

const timer = setTimeout(() => ev.emit("event", "fired!"), 1000)
timer.unref()

There’s a good talk about the event loop by Bert Belder here that clears up a lot of misconceptions: https://www.youtube.com/watch?v=PNa9OMajw9w

More Related Contents:

  1. When is .then(success, fail) considered an antipattern for promises?
  2. Is it bad practice to have a constructor function return a Promise?
  3. Issue in returning data retrieved from DB queries called in the loop
  4. Difference between microtask and macrotask within an event loop context
  5. Correct way to write loops for promise.
  6. Asynchronous exception handling with bluebird promises
  7. Promise Retry Design Patterns
  8. Using async/await with a forEach loop
  9. Handling multiple catches in promise chain
  10. Node JS Promise.all and forEach
  11. Understanding promises in Node.js
  12. How can I chain these functions together with promises?
  13. Catching Errors in JavaScript Promises with a First Level try … catch
  14. Are there still reasons to use promise libraries like Q or BlueBird now that we have ES6 promises? [closed]
  15. using async await and .then together
  16. How do I handle errors with promises?
  17. Why cant I inline call to res.json?
  18. Proper way to skip a then function in Q Promises
  19. How to structure nested Promises
  20. Why is my function returning Promise { } [duplicate]
  21. Limit concurrency of pending promises
  22. Difference of using async / await vs promises?
  23. Javascript Asynchronous Exception Handling with node.js
  24. Promise.all().then() resolve?
  25. Node.js: When to use Promises vs Callbacks
  26. Recursive Promises Not Returning
  27. Properly batch nested promises in Node
  28. what happens when a Promise never resolves? [duplicate]
  29. How to return a promise when writestream finishes?
  30. Weird behavior with Promise throwing “Unhandled promise rejection” error

Leave a Comment