Node.js事件循环中Promises与Callbacks的性能影响问询

Promises do introduce extremely minimal performance overhead in Node.js, but this cost is negligible for almost all real-world use cases. Let’s break down the details:

1. Microtask queue scheduling overhead #

When a Promise is resolved, its .then()/.catch() callbacks are added to the microtask queue. After the event loop finishes processing the poll phase, Node.js will empty the entire microtask queue before moving to the next phase. This adds a tiny layer of queue management compared to traditional callbacks:

• Traditional callback flow: I/O completes → callback runs directly in the poll phase
• Promise flow: I/O completes → Promise resolves → callback is queued as microtask → poll phase ends → microtask queue is drained and callbacks execute

Node.js’s microtask queues are heavily optimized, so this scheduling overhead is measured in nanoseconds—you won’t notice it in standard business logic.

2. Promise instance creation and state management #

Each Promise is an object that requires:

• Memory allocation for the instance itself
• Tracking of its state (pending/fulfilled/rejected)
• Storing a linked list of attached .then()/.catch() callbacks

Compared to a raw callback function reference, this adds a small amount of initialization and memory overhead. async/await is just syntactic sugar for Promises, so it carries the same minimal cost.

3. When does this overhead matter? #

The only scenario where this cumulative cost might be noticeable is in extremely high-throughput systems (e.g., processing millions of async operations per second)—like low-level frameworks or high-performance proxies where every nanosecond counts.

For most applications (web services, APIs, CLI tools), this overhead is completely overshadowed by the actual work your code does: database queries, network requests, or heavy computations typically take milliseconds to seconds, while Promise overhead is nanosecond-scale.

4. The tradeoff is worth it #

Even with the tiny performance cost, Promises (and async/await) provide massive benefits that far outweigh the overhead:

• Eliminates "callback hell" by flattening asynchronous code
• Provides a unified, structured error handling model (via .catch() or try/catch with async/await)
• Enables powerful async flow control with utilities like Promise.all(), Promise.race()
• Improves code readability and maintainability for you and your team

Example comparison #

Traditional callback:

func((err, data) => {
  if (err) {
    throw err;
  } else {
    doSomething(data);
  }
});

Promise-based approach:

funcPromise()
  .then(data => doSomething(data))
  .catch(err => { throw err });

// Or with async/await:
async function run() {
  try {
    const data = await funcPromise();
    doSomething(data);
  } catch (err) {
    throw err;
  }
}

内容的提问来源于stack exchange，提问作者Omar Handouk