Node learning how to minimize heap allocation and prevent memory leaks

How to check memory leaks in Node.js? The following article will introduce you to Nodejs heap allocation and introduce how to minimize heap allocation and prevent memory leaks. I hope it will be helpful to you!

#Memory management issues have always attracted much attention in the computer field. Each piece of software that runs on a computer is allocated a small portion of the computer's limited memory. This memory must be carefully managed and allocated or released at the appropriate time.

Nodejscan handle the tedious task of memory management through its efficient automatic garbage collection mechanism, thereby freeing developers to engage in other tasks. AlthoughNodejshas helped developers solve the problem of memory management, in the process of developing large-scale applications, it is difficult for developers to understandV8andNodejsThe memory management mechanism in is still very important.

This article mainly introduces how to allocate and release memory in the heap, and helps you know how to minimize heap allocation and prevent memory leaks. [Related tutorial recommendations:nodejs video tutorial,Programming teaching]

Heap allocation in Nodejs

JavaScriptandNode.jsabstract a lot of things away for you and do most of the heavy lifting behind the scenes.

We know that when a piece of code is executed, the variables and objects in the code will be stored in stack memory or heap memory,JavaScriptThe code will be stored in the code that will be executed. in the execution context.

ECMAScriptThe specification itself does not specify how memory is allocated and managed. This is an implementation detail that relies on theJavaScriptengine and underlying system architecture. A deep understanding of how the engine handles variables is beyond the scope of this article, but if you want to learn more about howV8does this, please refer to the articleJavaScript Memory Model Revealing howanddata are stored in V8 JS engine memory?.

Why is efficient heap memory usage important inNode.js?

Memory variables stored in the heap will always exist unless It is deleted or freed by the garbage collector. Heap memory is a large contiguous block of memory that remains in this state even after it is allocated and released.

Unfortunately, due to the way heap memory is collected and released, memory can be wasted, causing leaks.

V8uses a generational garbage collection mechanism, that is, it divides objects into different generations (new generation and old generation). The generation space will be divided into different areas - for example, the new generation consists of new space, and the old generation will be divided into old space, mapping space and large object space. New objects are initially allocated to the new generation space. When the new generation space is used up, the garbage collector will perform a cleanup mechanism to free up the space. Objects that survive oneGCrun are copied to the middle of the young generation, and objects that survive the second run are moved to the old generation.

Since the running program first collects memory, occupying precious virtual memory resources, when the memory is no longer needed, the program must release the memory, which is memory release.

In addition, if the memory is released (regardless of where it was previously released in the heap), the heap memory will be merged into a continuous block of memory. Due to the increased complexity of the heap memory, storing here will incur a higher performance overhead (but allows for greater flexibility in subsequent stores).

AlthoughNodejshas an efficient garbage collection mechanism, inefficient use of heap memory may lead to memory leaks. Applications may take up too much memory or even crash.

Causes of Nodejs Heap Memory Leak

The garbage collector will find and release orphaned memory spaces, but sometimes it may not be able to track every piece of memory. This can lead to unnecessary load increases, especially for large applications. We will discuss in detail how the garbage collector works inNodejslater.

Some of the most common causes of memory leaks include:

• Multiple references
• Global variables
• Closure
• Timer
• Event

Use multiple It is a very common operation to hold a reference to an object through a variable pointer. While this is very convenient for you, it can also cause a memory leak if one of the references to the object is collected by the garbage collector, but the other references are not.

InNode.jsandJavaScriptapplications, timers and callback functions that are forgotten to be cleaned are also two common causes of memory leaks. Objects bound to a timer will not be garbage collected until timeout. If the timer runs forever, the referenced object will never be collected by the garbage collector. This happens even if no variable pointer refers to the object, thus creating a memory leak in the heap.

Think about the sample code:

const language = () => { console.log("Javascript");】 // 递归自身 setTimeout(() => language(), 1000); }

The above code will always run and will never be recycled by the garbage collector

How to find out## Memory leaks in #Nodejs

Nodejs, includingChrome DevTools, the process ofNode. Garbage collector dashboard formemoryUsage APIandAppSignal.

Using Chrome DevTools

Chrome DevToolsProbably one of the easiest tools out there. To start the debugger, you need to start theNodeininspectmode. Runnode --inspectto do this.

Nodeisapp.js, you need to runnode --inspect app.jsto debug Node applications. Then, open theChromiumbrowser and enterchrome://inspect. You can also open the inspector page at Edge://inspect. In the inspector page, you should see a page like this:

Nodeapplication you are trying to debug appears in the inspector page bottom. Clickinspectto open the debugger. The debugger has two important tabs -MemoryandProfiler- but in this discussion we will focus on theMemorytab.

ChromeDebugger The easiest way to find memory leaks is to use aHeap Snapshot. Snapshots can help you inspect some variables or check their reserve size.

Heap snapshotand then click the *Take snapshotbutton. This may take some time, depending on your application'sTotal JSheap size. You can also load an existing snapshot by clicking theloadbutton at the bottom ofDevTool.

• Summary:Nodein the application based on the constructor name Objects are displayed in groups

• Comparison: Display the difference between two snapshots

• Containment: Allows you to look inside the heap and analyze objects referenced in the global namespace

• Statistics:

##There are two columns that stand out in the

heap analyzer - namelyShallow SizeandRetained Size.

Shallow Sizerepresents the size of the object itself in memory. This memory size is not large for most objects, except array and string types. On the other hand,Retained Sizeis the memory size released when the object in question and dependent objects are released or become inaccessible from the root node.

is not the only way to get a heap snapshot. If you are usingnodejs12.0 or higher, you can also run thenode --heapsnapshot-signalcommand:

node --heapsnapshot-signal=SIGUSR2 app.js

orSIGUSR2.If you obtain a pair snapshot from an application running on the server, you can use the

function in theV8package:

require("v8").writeHeapSnapshot();

这个方法要求 Nodejs的版本高于 11.13。在早期的版本中，你可以使用相关的包来实现。

let data = {}; data.el = data; let obj1 = {}; let obj2 = {}; obj1.a = obj2; obj2.a = obj1;

function variables() { this.a = "Variable one"; var b = "Variable two"; c = "Variable three"; }

const Person = { name: "Samuel", age: 25, language: "English" };

const Person = JSON.parse('{"name":"Samuel","age":25,"language":"English"}');

const timeout = setTimeout(() => { console.log("timeout"); }, 1500); const immediate = setImmediate(() => { console.log("immediate"); }); const interval = setInterval(() => { console.log("interval"); }, 500); clearTimeout(timeout); clearImmediate(immediate); clearInterval(interval);

const func = () => { let Person1 = { name: "Samuel", age: 25, language: "English" }; let Person2 = { name: "Den", age: 23, language: "Dutch" }; return () => Person2; };

const func = () => { let Person1 = { name: "Samuel", age: 25, language: "English" }; let Person2 = { name: "Den", age: 23, language: "Dutch" }; Person1 = null; return () => Person2; };

const EventEmitter = require("events").EventEmitter; const emitter = new EventEmitter(); const bigObject = {}; //Some big object const listener = () => { doSomethingWith(bigObject); }; emitter.on("event1", listener);

emitter.removeEventListener("event1", listener);

emitter.setMaxListeners(n);