Garbage collection mechanism

Complete high frequency question bank warehouse address ：https://github.com/hzfe/awesome-interview

Complete high frequency question bank reading address ：https://febook.hzfe.org/

Related issues

• What is memory leak
• Common garbage collection algorithms
• How to troubleshoot memory leaks

Answer key points

Reference counting Mark removal method Mark-Compact（ Tag to sort out ）Scavenger（ The sweeper ）

GC（Garbage Collection, Garbage collection ） Is an automatic memory management mechanism , Garbage collector （Garbage Collector） It can automatically reclaim the memory allocated to the program that is no longer used . common GC Algorithms include reference counting method and mark clearing method .V8（JavaScript engine , Provide execution JavaScript The runtime environment for ） The garbage collector algorithm is mainly composed of Mark-Compact and Scavenger constitute .

In depth knowledge

1. Memory leak

Memory leak means , Objects that should be recycled are not recycled normally , Become a permanent object of the older generation , Resulting in higher and higher memory consumption . Memory leaks can cause applications to slow down 、 High delay 、 Breakdown and so on .

1.1 Memory life cycle

1. Distribute ： Allocate memory on demand .
2. Use ： Read and write allocated memory .
3. Release ： Free up memory you no longer need .

1.2 Common causes of memory leaks

• Create global variables , And there is no manual recycling .
• Event listener / Timer / Closures, etc. are not cleaned properly .
• Use JavaScript Object to cache , The expiration policy and object size control are not set .
• The problem of untimely consumption caused by queue congestion .

2. Reference Counting（ Reference count ）

Reference Counting Is a common garbage collection algorithm , The core idea is ： Put resources （ Example object ） The number of citations of is saved , Release when the number of references is zero . The limitations of this method ： When there is a Circular reference when , Objects that reference each other are not recycled .

3. V8 Garbage collection mechanism

V8 There are two garbage collectors in the . The main GC Use Mark-Compact Garbage collection algorithm , Collect garbage from the whole heap . small GC Use Scavenger Garbage collection algorithm , Collect new generation garbage .

Two different algorithms deal with different scenarios ：

• Use Scavenger The algorithm mainly deals with Short life cycle Accessible objects in the object of .
• Use Mark-Compact The algorithm mainly deals with Long life cycle Inaccessible objects in the object .

Because there are a few accessible objects surviving in the Cenozoic , There are a few inaccessible objects in the older generation , Therefore, the combination of these two recycling algorithms is very efficient .

3.1 Generational garbage collection

stay V8 in , be-all JavaScript All objects pass Pile up To allocate .V8 Divide the heap it manages into two generations ： The new generation and the old generation . The Cenozoic can be subdivided into two sub generations （Nursery、Intermediate）.

That is, the objects in the Cenozoic are those with short survival time , Objects in an old generation are objects that have a long life or are memory resident .

3.2 Mark-Compact Algorithm （Major GC）

Mark-Compact The algorithm can be seen as Mark-Sweep（ Mark clear ） Algorithm and Cheney A combination of replication algorithms . The algorithm is mainly divided into three stages ： Mark 、 eliminate 、 Arrangement .

1. Mark （Mark） Tags are the process of finding all accessible objects .GC From a set of known object pointers （ Called root set , Including execution stack and global objects ） in , Recursively mark accessible objects .
2. eliminate （Sweep） Clearing is the memory space left by inaccessible objects , Add to free linked list （free list） The process of . When allocating memory for new objects in the future , You can reallocate from the free linked list .
3. Arrangement （Compact） Collation is to put accessible objects , The process of moving to one end of memory . It mainly solves the problem after the mark removal stage , When there are many memory fragments in the memory space , May result in failure to allocate large objects , The problem of triggering garbage collection in advance .

3.3 Scavenger Algorithm （Minor GC）

V8 The new generation memory space is Scavenger Algorithm , The algorithm uses semi-space（ Half space ） The design of the ： Divide the pile into two , Always use only half the space ：From-Space To use space ,To-Space For free space .

The new generation is in From-Space Objects assigned in ; In the garbage collection phase , Check and copy as needed From-Space The accessible objects in the are to To-Space Or the old generation , And release From-Space Memory space occupied by inaccessible objects in ; Last From-Space and To-Space Role exchange .

Reference material

1. Memory Management
2. Trash talk: the Orinoco garbage collector