Let's briefly talk about the content of js garbage collection

This article mainly introduces the garbage collection mechanism of js, which has certain reference value. Now I share it with everyone. Friends in need can refer to it

Garbage Collection

Memory Management It is automatic and invisible to us. The primitive types, objects, functions, etc. we create all occupy memory.

What happens when they are no longer needed? How does the JavaScript engine find and clear them?

Reachability

The key concept in JavaScript memory management is Reachability.

Simply put, "reachable" values ​​are accessible and available, and they are safely stored in memory.

1. The following are some values ​​that must be "reachable" and cannot be deleted for any reason:

• Current function local variables and parameters.

• Local variables and parameters of all functions in the current chain of nested calls.

• Global variables.

• (and other internal variables)

这些值都称为 *roots*。

1. Whether other values ​​are reachable depends on whether it is root and its reference chain reference.

   Suppose there is an object existing in a local variable, and its value refers to another object. If this object is reachable, the object it refers to is also reachable. Detailed examples will be given later.

The JavaScript engine has a garbage collection) background process. It monitors all objects and deletes them when they become unreachable.

A simple example

// user has a reference to the object
let user = {
  name: "John"
};

The arrow represents an object reference. Global variable "user" refers to object {name: "John"} (referred to as John). John's "name" attribute stores a primitive value, so there is no other reference.

If you overwrite user, the reference to John is lost:

user = null;

Now John becomes untouchable and the garbage collection mechanism It will be deleted and the memory will be freed.

Two references

If we copy the reference from user to admin:

// user has a reference to the object
let user = {
  name: "John"
};

*!*
let admin = user;
*/!*

If you repeat this operation:

user = null;

... This object can still be accessed through admin, so it still exists in memory. If we also overwrite admin to null, it will be deleted.

Objects that reference each other

This example is more complicated:

function marry(man, woman) {
  woman.husband = man;
  man.wife = woman;

  return {
    father: man,
    mother: woman
  }
}

let family = marry({
  name: "John"
}, {
  name: "Ann"
});

marry The function makes two parameter objects refer to each other and returns an object containing both New objects, with the following structure:

Temporarily all objects are reachable, but we have now decided to remove two references:

delete family.father;
delete family.mother.husband;

Deleting only one reference will not have any impact, but if both references are deleted at the same time, we can see that John is no longer referenced by any object:

Even though John is still referencing others, he is not quoted by others, so John is now untouchable and his existence will be removed.

After garbage collection:

Unreachable island

There may also be a lot of object blocks that reference each other (like Islands) are out of reach.

Operation on the above object:

family = null;

The situation in the memory is as follows:

This example shows the "touchable" The importance of concepts.

Even though John and Ann relied on each other, it wasn't enough.

"family" The entire object has been cut off from the root connection, and nothing refers to it, so this island is out of reach and can only wait to be deleted.

Internal Algorithm

The basic garbage collection algorithm is called the "mark-and-sweep" algorithm:

• Garbage Collector Get and mark root.

• Then access and tag all citations from them.

• To access marked objects, mark their references. All visited objects are recorded and the same object will not be accessed repeatedly in the future.

• ...until only unvisited references remain.

• All unmarked objects will be removed.

Assume that the object structure is as follows:

We clearly see the "isolated island" on the right. Now use the "mark and clear" method to deal with it.

The first step is to mark the root:

and then mark their references:

… ...mark the references they refer to:

Objects that have not been accessed are now considered unreachable and they will be deleted:

This is how garbage collection works.

The JavaScript engine has made a lot of optimizations without affecting execution, making this process more garbage collection efficient:

• Generational collection -- Objects will be divided into "new generation" and "old generation". Many objects are no longer needed soon after completing their tasks, so they can be cleaned up frequently. Those left behind during the cleanup are called members of the "old generation".

• Incremental collection -- If there are many objects, it is difficult to mark all objects at once. This process even causes a significant delay in program execution. So the engine will try to split this operation into multiple parts and execute one part at a time. Doing so requires recording additional data, but can effectively reduce the impact of latency on user experience.

• Idle-time collection -- The garbage collector tries to run only when the CPU is idle to reduce the impact on program execution.

In addition, there are many optimizations for garbage collection, which I won’t go into details here. Each engine has its own adjustments and technologies, and this thing has been updated with the engine. Generations are changing. If there is no real demand, it is not worth digging too deep. But if you are really interested in this, some expansion links will be provided below.

Summary

Key points:

• Garbage collection occurs automatically, and we cannot force it or prevent it.

• Reachable objects will be retained in memory.

• References are not necessarily reachable (from root): objects that reference each other may be entirely unreachable.

Modern engines implement enhanced garbage collection algorithms, and they are mentioned in the book "The Garbage Collection Handbook: The Art of Automatic Memory Management" (R. Jones et al.).

If you are familiar with low-level programming, you can read A tour of V8: Garbage Collection to learn more details about V8 garbage collection.

V8 blog also frequently publishes articles about memory management. The best way to learn the garbage collection algorithm is to first learn the V8 implementation and read the blog of Vyacheslav Egorov (one of the V8 engineers). I say V8 because there are many articles about V8 on the Internet. For other engines, many implementations are similar, but there are many differences in garbage collection algorithms.

An in-depth understanding of the engine is very helpful when doing low-level optimization. After you become familiar with a language, this is a smart direction to pursue.

The above is the entire content of this article. I hope it will be helpful to everyone's study. For more related content, please pay attention to the PHP Chinese website!

Related recommendations:

How to use js to determine whether the page is opened on the pc side or on the mobile side

Detailed explanation of prototype

The above is the detailed content of Let's briefly talk about the content of js garbage collection. For more information, please follow other related articles on the PHP Chinese website!