A brief analysis of JS garbage collection mechanism and memory management

This article mainly introduces a brief analysis of JS garbage collection mechanism and memory management. The editor thinks it is quite good. Now I will share it with you and give it as a reference. Let’s follow the editor to take a look.

Garbage collection

The garbage collection mechanism in javascript is very simple: find those variables that are no longer in use, and then release them.

Local variables only exist during the execution of the function, so when the function execution ends, there is no need for local variables to exist. But not all variables are so easy to judge, so some methods must be used to recycle them Variable

1 Mark clearing:

The most commonly used garbage collection method in JavaScript is to clear the mark. When a variable enters the environment, mark the variable as "Enter the environment" , when the variable leaves the environment, mark the variable as "leaving the environment". Generally speaking, we will only clear the variables with the leaving environment mark, because there is no way to access them. Then the garbage collector completes the memory clearing work.

2 Reference counting:

This method is not so commonly used. The meaning of reference counting is to record the number of times each value is referenced. When the number of references is reduced to 0, It means that there is no way to access that value anymore, so the memory occupied by it can be released.

But there is a problem with reference counting: circular reference. For example:

function problem(){
var objectA = new Object();
var objectB = new Object();
objectA.someOtherObject = objectB;
objectB.anotherObject = objectA;
}

In this example, in this example, objectA and objectB reference each other through their respective properties; that is, the number of times these two objects are referenced

Both are 2. In an implementation that uses a mark-and-sweep strategy, this mutual reference is not a problem because both objects go out of scope after the function is executed. But in an implementation that uses a reference counting strategy, objectA and objectB will continue to exist after the function is executed, because their number of references will never be 0. If this function is called multiple times, a large amount of memory will not be recycled

In order to avoid such a problem, we need to set them to null when they are not used to eliminate circular references

Memory Management:

We all know that the amount of available memory allocated to web browsers is usually less than that allocated to desktop applications. The purpose of this is mainly for security reasons, and the purpose is to prevent a web page running JavaScript from using up all the system memory and causing the system to crash. Memory limit issues not only affect the allocation of memory for variables, but also the call stack and the number of statements that can be executed simultaneously in a thread.

Therefore, ensuring that the least amount of memory is occupied can allow the page to achieve better performance. The best way to optimize memory usage is to save only the necessary data for the executing code. Once the data is no longer useful, it's a good idea to release its reference by setting its value to null—a practice called dereferencing. This approach applies to most global variables and properties of global objects. Local variables will be automatically dereferenced when they leave the execution environment, as shown in the following example:

function createPerson(name){
var localPerson = new Object();
localPerson.name = name;
return localPerson;
}
var globalPerson = createPerson("Nicholas");
// 手工解除globalPerson 的引用
globalPerson = null;

Dereferencing a value does not mean automatically recycling the memory occupied by the value. What a dereference really does is take the value out of the execution environment so that it can be reclaimed by the garbage collector the next time it runs.

Related recommendations:

java garbage collection mechanism, memory management

JS garbage collection mechanism and memory allocation

JavaScript garbage collection mechanism and memory leak problem

The above is the detailed content of A brief analysis of JS garbage collection mechanism and memory management. For more information, please follow other related articles on the PHP Chinese website!