在async函数中迭代Promise时内存占用显著升高问题排查

Let's break down the memory behavior you're seeing in your async loop, and why it varies between Node.js versions.

First, here's the code you're testing for reference:

async function a () {
  for (let i = 0; i < 10000000000; i++) {
    await new Promise(resolve => {
      if (i%100000 === 0) {
        console.log(i)
        console.log(process.memoryUsage())
      }
      resolve(i)
    })
  }
}
a()

为什么内存会在特定迭代点跳升？ #

The key culprit here is V8's dynamic heap memory management (Node.js uses the V8 engine under the hood):

• Every iteration of your loop creates a new Promise and uses await, which generates small execution context snapshots and promise objects that stay in memory until V8's garbage collector (GC) cleans them up.
• V8 keeps track of how much of its allocated heap (heapTotal) is actually in use (heapUsed). When heapUsed reaches a certain threshold relative to heapTotal, V8 first tries to run a GC to free up space. If that's not enough to handle upcoming allocations, it expands the total heap size—this is what causes the sudden jump in heapTotal and RSS (the process's overall memory footprint) you're seeing.

Your logs confirm this pattern clearly:

在Node.js 7.9.0版本中，跳升总是发生在i从2000000到2100000之间：
2000000 { rss: 19357696, heapTotal: 9355264, heapUsed: 5587808, external: 8772 }
2100000 { rss: 23605248, heapTotal: 13549568, heapUsed: 6088208, external: 8772 }

在Node.js 8.3.0版本中，跳升总是发生在i从2600000到2700000之间：
2600000 { rss: 30539776, heapTotal: 9437184, heapUsed: 4636176, external: 8252 }
2700000 { rss: 34742272, heapTotal: 13631488, heapUsed: 6606512, external: 8252 }

为什么不同Node.js版本的跳升点不同？ #

The shift in when the memory jump occurs comes down to V8 version differences:

• Node.js 7.9.0 uses V8 5.5, while Node.js 8.3.0 uses V8 6.0. Each V8 update tweaks heap expansion thresholds, GC trigger logic, and memory optimization rules.
• The newer V8 in Node 8.3.0 is more efficient at managing async contexts and delaying heap expansion, so it takes more iterations (2.6M vs 2.0M) before the threshold is crossed.

验证这个结论 #

To confirm this is indeed heap expansion at work:

• Run your script with Node's --expose-gc flag, which lets you manually trigger garbage collection. Add this line inside your loop (e.g., when i%200000 === 0):

  global.gc();
  

  You'll see heapUsed drop drastically after each GC, and the heap expansion will either be delayed or happen at a much higher iteration count.

优化建议（针对实际代码） #

If you're writing production code that needs to avoid unexpected memory spikes:

• Avoid unnecessary promises in tight loops: Since your promise resolves immediately, you can replace await new Promise(...) with await Promise.resolve(i) (newer V8 versions cache resolved promises, reducing overhead) or even remove the await entirely if you don't need the async pause.
• Batch work: Instead of processing one item at a time, batch iterations to reduce the number of async context snapshots V8 has to track.
• Use memory profiling tools: Tools like Node's built-in --inspect flag (for Chrome DevTools profiling) can help you visualize heap allocations and GC cycles in detail.

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