理解和调优内存

¥Understanding and Tuning Memory

Node.js 基于 Google 的 V8 JavaScript 引擎构建，为在服务器端运行 JavaScript 提供了强大的运行时环境。但是，随着应用的增长，管理内存对于保持最佳性能和管理内存泄漏或崩溃等问题至关重要。在本文中，我们将探讨如何在 Node.js 中监控、管理和优化内存使用情况。我们还将介绍 V8 的一些重要概念，例如堆和垃圾回收，并讨论如何使用命令行标志来微调内存行为。

¥Node.js, built on Google's V8 JavaScript engine, offers a powerful runtime for running JavaScript on the server side. However, as your applications grow, managing memory becomes a critical task for maintaining optimal performance and managing problems like memory leaks or crashes. In this article, we'll explore how to monitor, manage, and optimize memory usage within Node.js. We'll also cover important V8 concepts like the heap and garbage collection and discuss how to use command-line flags to fine-tune memory behavior.

V8 如何管理内存

¥How V8 Manages Memory

V8 的核心是将内存划分为几个部分，其中两个主要区域是堆和栈。了解这些空间，尤其是堆的管理方式，是改善应用内存使用率的关键。

¥At its core, V8 divides memory into several parts, with two primary areas being the heap and the stack. Understanding these spaces, especially how the heap is managed, is key to improving memory usage in your app.

堆

¥The Heap

V8 的内存管理基于分代假说，即大多数对象都会在年轻时消亡。因此，它将堆划分为几代以优化垃圾回收：

¥V8's memory management is based on the generational hypothesis, the idea that most objects die young. Therefore, it separates the heap into generations to optimize garbage collection:

1. 新空间：这是分配新的、短期对象的地方。此处的对象预计为 "die young"，因此垃圾回收会频繁发生，从而允许快速回收内存。

   ¥New Space: This is where new, short-lived objects are allocated. Objects here are expected to "die young", so garbage collection occurs frequently, allowing memory to be reclaimed quickly.

   例如，假设你有一个 API 每秒接收 1,000 个请求。每个请求都会生成一个临时对象（例如 { name: 'John', age: 30 }），该对象在请求处理后会被丢弃。如果你将“新空间”大小保留为默认值，V8 将频繁执行小型垃圾回收来清除这些小对象，从而确保内存使用量保持在可控范围内。

   ¥For example, let's say you have an API that receives 1,000 requests per second. Each request generates a temporary object like { name: 'John', age: 30 }, which is discarded once the request is processed. If you leave the New Space size at the default, V8 will frequently perform minor garbage collections to clear these small objects, ensuring that memory usage remains manageable.

2. 旧空间：在新空间中经历多次垃圾回收周期后仍存活下来的对象将被提升到旧空间。这些通常是长期存在的对象，例如用户会话、缓存数据或持久状态。由于这些对象通常持续时间较长，因此此空间的垃圾收集频率较低，但资源占用更高。

   ¥Old Space: Objects that survive multiple garbage collection cycles in the New Space are promoted to the Old Space. These are usually long-lived objects, such as user sessions, cache data, or persistent state. Because these objects tend to last longer, garbage collection in this space occurs less often but is more resource-intensive.

   假设你正在运行一个跟踪用户会话的应用。每个会话都可能存储类似 { userId: 'abc123', timestamp: '2025-04-10T12:00:00', sessionData: {...} } 的数据，这些数据需要在用户处于活动状态时一直保留在内存中。随着并发用户数量的增长，旧空间可能会被填满，从而导致内存不足错误或响应时间因低效的垃圾收集周期而变慢。

   ¥Let's say you are running an application that tracks user sessions. Each session might store data like { userId: 'abc123', timestamp: '2025-04-10T12:00:00', sessionData: {...} }, which needs to persist in memory as long as the user is active. As the number of concurrent users grows, the Old Space could fill up, causing out-of-memory errors or slower response times due to inefficient garbage collection cycles.

在 V8 中，JavaScript 对象、数组和函数的内存是在堆中分配的。堆的大小不是固定的，超过可用内存量可能会导致 "out-of-memory" 错误，从而导致应用崩溃。

¥In V8, memory for JavaScript objects, arrays, and functions is allocated in the heap. The size of the heap is not fixed, and exceeding the available memory can result in an "out-of-memory" error, causing your application to crash.

要检查当前堆大小限制，你可以使用 v8 模块。

¥To check the current heap size limit, you can use the v8 module.

const v8 = require('node:v8');
const { heap_size_limit } = v8.getHeapStatistics();
const heapSizeInGB = heap_size_limit / (1024 * 1024 * 1024);

console.log(`${heapSizeInGB} GB`);

这将输出最大堆大小（以 GB 为单位），该大小取决于你系统的可用内存。

¥This will output the maximum heap size in gigabytes, which is based on your system's available memory.

堆栈

¥The Stack

除了堆之外，V8 还使用栈进行内存管理。堆栈是用于存储局部变量和函数调用信息的内存区域。与由 V8 垃圾收集器管理的堆不同，堆栈遵循后进先出 (LIFO) 原则。

¥In addition to the heap, V8 also uses the stack for memory management. The stack is a region of memory used to store local variables and function call information. Unlike the heap, which is managed by V8's garbage collector, the stack operates on a Last In, First Out (LIFO) principle.

每当调用一个函数时，一个新的框架都会被压入堆栈。当函数返回时，其框架会被弹出。栈的大小比堆小得多，但内存分配和释放速度更快。但是，堆栈的大小是有限的，过度使用内存（例如深度递归）可能会导致堆栈溢出。

¥Whenever a function is called, a new frame is pushed onto the stack. When the function returns, its frame is popped off. The stack is much smaller in size compared to the heap, but it is faster for memory allocation and deallocation. However, the stack has a limited size, and excessive use of memory (such as with deep recursion) can result in a stack overflow.

监控内存使用情况

¥Monitoring Memory Usage

在调整内存使用情况之前，了解应用消耗的内存量非常重要。Node.js 和 V8 提供了多种用于监控内存使用情况的工具。

¥Before tuning memory usage, it's important to understand how much memory your application is consuming. Node.js and V8 provide several tools for monitoring memory usage.

使用 process.memoryUsage()

¥Using process.memoryUsage()

process.memoryUsage() 方法可以深入了解 Node.js 进程正在使用的内存量。它返回一个包含如下详细信息的对象：

¥The process.memoryUsage() method provides insights into how much memory your Node.js process is using. It returns an object with details like:

• rss（驻留集大小）：分配给进程的总内存，包括堆和其他区域。

  ¥rss (Resident Set Size): The total memory allocated to your process, including heap and other areas.

• heapTotal：分配给堆的总内存。

  ¥heapTotal: The total memory allocated for the heap.

• heapUsed：堆中当前正在使用的内存。

  ¥heapUsed: The memory currently in use within the heap.

• external：外部资源（例如绑定到 C++ 库）使用的内存。

  ¥external: Memory used by external resources like bindings to C++ libraries.

• arrayBuffers：分配给各种类似缓冲区对象的内存。

  ¥arrayBuffers: Memory allocated to various Buffer-like objects.

以下是如何使用 process.memoryUsage() 监控应用的内存使用情况：

¥Here's how to use process.memoryUsage() to monitor memory usage in your application:

console.log(process.memoryUsage());

输出将显示每个区域的内存使用量：

¥The output will show how much memory is being used in each area:

{
  "rss": 25837568,
  "heapTotal": 5238784,
  "heapUsed": 3666120,
  "external": 1274076,
  "arrayBuffers": 10515
}

通过随时间监控这些值，你可以识别内存使用量是否意外增加。例如，如果 heapUsed 持续增长而未被释放，则可能表明你的应用存在内存泄漏。

¥By monitoring these values over time, you can identify if memory usage is increasing unexpectedly. For instance, if heapUsed steadily grows without being released, it could indicate a memory leak in your application.

用于内存调优的命令行标志

¥Command-Line Flags for Memory Tuning

Node.js 提供了多个命令行参数来微调与内存相关的设置，从而允许你优化应用中的内存使用情况。

¥Node.js offers several command-line flags to fine-tune memory-related settings, allowing you to optimize memory usage in your application.

--max-old-space-size

此标志限制 V8 堆中旧空间（用于存储长寿命对象）的大小。如果你的应用使用了大量内存，则可能需要调整此限制。

¥This flag sets a limit on the size of the Old Space in the V8 heap, where long-lived objects are stored. If your application uses a significant amount of memory, you might need to adjust this limit.

例如，假设你的应用处理稳定的传入请求流，每个请求都会生成一个大对象。随着时间的推移，如果这些对象未被清除，旧空间可能会超载，导致崩溃或响应时间变慢。

¥For example, lets say your application handles a steady stream of incoming requests, each of which generates a large object. Over time, if these objects are not cleared, the Old Space could become overloaded, causing crashes or slower response times.

你可以通过设置 --max-old-space-size 标志来增加旧空间的大小：

¥You can increase the Old Space size by setting the --max-old-space-size flag:

node --max-old-space-size=4096 app.js

这会将旧空间大小设置为 4096 MB (4 GB)，如果你的应用正在处理大量持久数据（例如缓存或用户会话信息），这将特别有用。

¥This sets the Old Space size to 4096 MB (4 GB), which is particularly useful if your application is handling a large amount of persistent data, like caching or user session information.

--max-semi-space-size

此标志控制 V8 堆中新空间的大小。新空间是新创建的对象被频繁分配和垃圾回收的地方。增加栈的大小可以减少小型垃圾回收周期的频率。

¥This flag controls the size of the New Space in the V8 heap. New Space is where newly created objects are allocated and garbage collected frequently. Increasing this size can reduce the frequency of minor garbage collection cycles.

例如，如果你有一个 API 接收大量请求，每个请求都会创建像 { name: 'Alice', action: 'login' } 这样的小对象，你可能会注意到频繁的垃圾回收导致性能下降。通过增加“新空间”的大小，你可以降低这些回收的频率并提高整体性能。

¥For example, if you have an API that receives a large number of requests, each creating small objects like { name: 'Alice', action: 'login' }, you may notice performance degradation due to frequent garbage collection. By increasing the New Space size, you can reduce the frequency of these collections and improve overall performance.

node --max-semi-space-size=64 app.js

这会将新空间 (New Space) 增加到 64 MB，从而允许更多对象在触发垃圾回收之前驻留在内存中。这在对象创建和销毁频繁的高吞吐量环境中尤其有用。

¥This increases the New Space to 64 MB, allowing for more objects to reside in memory before triggering garbage collection. This is particularly useful in high-throughput environments where object creation and destruction are frequent.

--gc-interval

此标志调整垃圾收集周期的发生频率。默认情况下，V8 会确定最佳间隔，但在某些需要更好地控制内存清理的情况下，你可以覆盖此设置。

¥This flag adjusts how frequently garbage collection cycles occur. By default, V8 determines the best interval, but you can override this setting in some scenarios where you need more control over memory cleanup.

例如，在股票交易平台等实时应用中，你可能希望通过降低回收频率来最大限度地减少垃圾回收的影响，确保应用能够在不出现明显停顿的情况下处理数据。

¥For example, in a real-time application like a stock trading platform, you may want to minimize the impact of garbage collection by reducing the frequency of collections, ensuring the application can process data without significant pauses.

node --gc-interval=100 app.js

此设置强制 V8 每 100 毫秒尝试一次垃圾回收。你可能需要根据特定用例调整此间隔，但请谨慎：将间隔设置得太低可能会导致性能下降，因为垃圾回收周期过多。

¥This setting forces V8 to attempt garbage collection every 100 ms. You may need to adjust this interval for specific use cases, but be cautious: setting the interval too low can cause performance degradation due to excessive garbage collection cycles.

--expose-gc

使用 --expose-gc 标志，你可以在应用代码中手动触发垃圾回收。这在特定场景下非常有用，例如在处理大量数据后，你需要在继续执行后续操作之前回收内存。

¥With the --expose-gc flag, you can manually trigger garbage collection from within your application code. This can be helpful in specific scenarios, like after processing a large batch of data, where you want to reclaim memory before continuing with further operations.

要展示 gc，请从以下位置启动你的应用：

¥To expose gc, start your app with:

node --expose-gc app.js

然后，在应用代码中，你可以调用 global.gc() 手动触发垃圾回收：

¥Then, within your application code, you can call global.gc() to manually trigger garbage collection:

global.gc();

请记住，手动触发垃圾回收不会禁用正常的 GC 算法。V8 仍将根据需要执行自动垃圾收集。手动调用仅供补充，应谨慎使用，因为过度使用会对性能产生负面影响。

¥Keep in mind that manually triggering garbage collection does not disable the normal GC algorithm. V8 will still perform automatic garbage collection as needed. Manual calls are supplemental and should be used with caution, as overuse can negatively impact performance.

其他资源

¥Additional Resources

要深入了解 V8 如何处理内存，请查看 V8 团队的以下帖子：

¥To dive deeper into how V8 handles memory, check out these posts by the V8 team:

• 废话：Orinoco 垃圾收集器

  ¥Trash talk: the Orinoco garbage collector

• Orinoco：年轻代垃圾收集

  ¥Orinoco: young generation garbage collection

综合起来

¥Putting It All Together

通过调整旧空间和新空间大小的设置、选择性地触发垃圾收集以及配置堆限制，你可以优化应用的内存使用情况并提高其整体性能。这些工具使你能够在高需求场景中更好地管理内存，并在应用扩展时保持稳定性。

¥By adjusting settings for the Old Space and New Space sizes, selectively triggering garbage collection, and configuring heap limits, you can optimize your application’s memory usage and improve its overall performance. These tools give you the power to better manage memory in high-demand scenarios and maintain stability as your applications scale.