JVM garbage collection mechanism

One 、 Methods for judging garbage objects

Reference counting

Add a reference counter to the object , Whenever there is a place to quote it , The counter is added 1; When a reference fails , The counter goes down 1; Any time the counter is 0 It is impossible to use the object of .

This method is easy to implement , Efficient , But at present, the mainstream virtual machine does not choose this algorithm to manage memory , The main reason is that it is difficult to solve The problem of circular references between objects . The so-called mutual reference between objects , As shown in the following code ： Except for objects objA and objB Quote each other , There is no more reference between the two objects . But they cite each other , The reference counters that cause them are not 0, So the reference counting algorithm can't notify GC The recyclers recycle them .

public class ReferenceCountingGc {

  Object instance = null;

  public static void main(String[] args) {
   ReferenceCountingGc objA = new ReferenceCountingGc();
   ReferenceCountingGc objB = new ReferenceCountingGc();
   objA.instance = objB;
   objB.instance = objA;
   objA = null;
   objB = null;
  } 
}

Reachability analysis algorithm

take “GC Roots” Object as starting point , Start from these nodes and drill down to the referenced objects , All objects found are marked as Non garbage objects , The rest of the unmarked objects are garbage objects

GC Roots The root node ：

 

 1.  Objects referenced in the virtual machine stack ( Local variable table in stack frame )

 

 2. Native Method Stack JNI(Java Native Interface) Referenced object

 3. Object referenced by static property of method area class

 4. Object referenced by method area constant pool

 5. Objects referenced by active threads

Two 、 Common reference types

java There are generally four types of references ： Strong citation 、 Soft citation 、 Weak reference 、 Virtual reference

Strong citation ： Common variable references

 public static User user = new User();

Soft citation ： Use the object as SoftReference Object wrap of soft reference type , Normal conditions will not be recycled , however GC After that, I found that I couldn't release space to store new objects , Then the soft reference objects will be recycled . Soft references can be used to implement memory sensitive caching .

public static SoftReference<User> user = new SoftReference<User>(new User());

Soft reference has important application in practice , For example, the browser's back button . When you press back , Is the content of the webpage displayed in the back page re requested or removed from the cache ？ It depends on the specific implementation strategy .

（1） If a web page is recycled at the end of browsing , When you press back to view the previously viewed page , Need to rebuild

（2） If the browsing web pages are stored in memory, it will cause a lot of memory waste , It can even cause a memory overflow

Weak reference ： Use the object as WeakReference Object wrap of soft reference type , Weak references are almost like no references ,GC It will be recycled directly , Rarely used

public static WeakReference<User> user = new WeakReference<User>(new User());

Virtual reference ： Virtual quotation is also called ghost quotation or phantom quotation , It's the weakest kind of reference , Almost no use

3、 ... and 、finalize() Methods to determine whether the object is alive or not

Even unreachable objects in the reachability analysis algorithm , It's not “ Must die ” Of , At this time they are temporarily in “ Probation ” Stage , To actually declare an object dead , At least go through the process of marking again .

The premise of tagging is that the object is found not to be related to GC Roots Linked reference chain .

1. Mark for the first time and perform a screening .

The condition for filtering is whether the object is necessary to execute finalize() Method . When the object is not overridden finalize Method , Objects will be recycled directly .

2. The second mark

If this object covers finalize Method ,finalize The method is the last chance for the object to escape death , If the object is to be finalize() To save yourself , Just re associate with any object in the reference chain , For example, assign yourself to a class variable or a member variable of an object , Then it will be removed at the second time “ About to be recycled ” Set . If the object hasn 't escaped yet , So basically it's really recycled .

Be careful ： Of an object finalize() Method will only be executed once , That is, by calling finalize The way to save your life is just once .

Four 、 How to judge a class is useless

Method area mainly recycles useless classes , So how to judge whether a class is useless ？

The class needs to satisfy both the following 3 It's a condition “ Useless class ” ：

1. All instances of this class have been reclaimed , That is to say Java There are no instances of this class in the heap .

2. Load the class ClassLoader Has been recovered .

3. Corresponding to this class java.lang.Class The object is not referenced anywhere , The methods of the class cannot be accessed anywhere by reflection .

5、 ... and 、 Garbage collection algorithm

Generational collection algorithm

     According to the different life cycle of objects, different garbage collection algorithms are used . Almost all Java The heap uses this algorithm .

Copy algorithm

    Divide the memory into object faces and free faces . When the memory of the object face runs out , Copy the live object in the object face to the memory of the free face , Then clear the object memory of the object face .

characteristic ： No memory fragmentation , Because it uses continuous memory allocation , Make it simple and efficient ,“ Mark - eliminate ” or “ Mark - Arrangement ” The algorithm will be slower than the copy algorithm 10 More than times . Copy algorithm It is suitable for scenes with low survival rate of objects , For example, the garbage collection of the younger generation . It is necessary to use the backup memory to deal with the situation that the free side memory is insufficient .

Mark - Clear algorithm

    After finding garbage objects and marking them with reachability algorithm , The heap memory will be traversed linearly from beginning to end , Reclaim unreachable objects . Then, the identifier that was originally marked as a reachable object is cleared , For the next recycling .

shortcoming ： Low efficiency , Neither marking nor clearing is efficient . Easy to cause memory fragmentation , When a large object needs to allocate space , It is easy to trigger another time because you cannot find enough continuous memory GC.

Mark - Sorting algorithm

    After finding garbage objects and marking them with reachability algorithm , Move all living objects , And sort by memory address , Then recycle all the memory after the end memory address . It costs more to recover , But there is no memory fragmentation . It is suitable for scenes with high object survival rate .

6、 ... and 、 Garbage collector

If the collection algorithm is the methodology of memory recycling , So garbage collector is the concrete implementation of memory recycling .

Although we compare the collectors , But not to pick out the best collector . Because until now, there is no best garbage collector , There is no universal garbage collector , What we can do is to choose the garbage collector suitable for ourselves according to the specific application scenario . Just imagine ： If there is a kind of four seas 、 The perfect collector for any scenario exists , So our Java Virtual machines don't implement so many different garbage collectors .

1.1 Serial The collector (-XX:+UseSerialGC -XX:+UseSerialOldGC)

Serial（ Serial ） The collector is the most basic 、 The oldest garbage collector . You can see from the name that this collector is a single thread collector . its “ Single thread ” It doesn't just mean that it only uses one garbage collection thread to complete the garbage collection work , What's more, it must pause all other working threads when it is doing garbage collection work （ "Stop The World" ）, Until it's collected .

The new generation uses replication algorithms , The old days use signs - Sorting algorithm .

Of course, the designers of virtual machines know Stop The World Bad user experience , So in the subsequent garbage collector design, the pause time is constantly shortened （ There is still a pause , The search for the best garbage collector continues ）.

however Serial Is the collector superior to other garbage collectors ？ Of course. , it Simple and efficient （ Compared with the single thread of other collectors ）.Serial The collector has no overhead of thread interaction , Naturally, high single thread collection efficiency can be achieved .

Serial Old The collector is Serial Old age version of collector , It is also a single-threaded collector . It has two main uses ： One use is in JDK1.5 As well as previous versions of the Parallel Scavenge Collector used with , Another use is for CMS The backup plan of the collector .

1.2 Parallel Scavenge The collector (-XX:+UseParallelGC( The younger generation ),-XX:+UseParallelOldGC( Old age ))

Parallel The collector is actually Namely Serial Multithreaded version of collector , In addition to using multithreading for garbage collection , The rest of the action （ Control parameter 、 Collection algorithm 、 Recycling strategies, etc ） and Serial Collector similar . The default number of collection threads follows cpu Same number of cores , Of course, you can also use parameters (-XX:ParallelGCThreads) Specify the number of collection threads , But generally, it is not recommended to modify .

Parallel Scavenge The collector's focus is throughput （ Make efficient use of CPU）.CMS Wait for the garbage collector to focus more on the user thread stop Time （ Improve user experience ）. Throughput is CPU Time used to run user code and CPU Ratio of total elapsed time . ParallelScavenge The collector provides many parameters for the user to find the most appropriate pause time or maximum throughput , If you don't know much about collector operation , It is also a good choice to leave the memory management optimization to the virtual machine .

The new generation uses replication algorithms , The old days use signs - Sorting algorithm .

Parallel Old The collector is Parallel Scavenge Old age version of collector . Using multithreading and “ Mark - Arrangement ” Algorithm . Focus on throughput and CPU The occasion of resources , You can give priority to Parallel Scavenge Collectors and Parallel Old The collector (JDK8 The default collection for the new and old generations device ).

1.3 ParNew The collector (-XX:+UseParNewGC)

ParNew The collector is actually Follow Parallel Collectors are very similar , The main difference is that it can be compared with CMS Collector in conjunction .

The new generation uses replication algorithms , The old days use signs - Sorting algorithm .

It's a lot of running in Server The first choice of virtual machine in mode , except Serial Outside the collector , Only it can be with CMS The collector （ A truly concurrent collector , It will be introduced later ） Cooperation .

1.4 CMS The collector (-XX:+UseConcMarkSweepGC(old))

CMS（Concurrent Mark Sweep） A collector is one that aims to obtain the shortest recovery pause time . It is very consistent with the focus on the user body Use on the application of test , It is HotSpot The first real concurrent collector of virtual machine , It's the first time it's implemented to let garbage collection thread and user thread （ Basically ） Work at the same time .

From the name Mark Sweep These two words show that ,CMS The collector is a kind of “ Mark - eliminate ” Algorithm Realized , Its operation process is more complicated than the previous garbage collectors . The whole process is divided into four steps ：

Initial marker ： Pause all other threads (STW), And record gc roots Objects that can be referenced directly , fast .

Concurrent Tags ： The concurrent marking phase is from GC Roots The process of traversing the whole object graph begins with the directly related object , This process takes a long time but does not need to pause the user thread , Can run concurrently with the garbage collection thread . Because the user program continues to run , There may be changes in the state of the marked object .

Re label ： The retag stage is to fix the tag record of the part of objects whose tags change because the user program continues to run , The pause time of this stage is generally a little longer than that of the initial marking stage , Far less time than concurrent markup phase . It mainly uses three In the color mark Incremental update algorithm ( See details below ) Mark it again .

Concurrent cleanup ： Open user thread , meanwhile GC The thread starts to clean up the unmarked area . If there are new objects in this stage, they will be marked as black and will not be processed ( See the detailed explanation of the three color marking algorithm below ).

Concurrent reset ： Reset this time GC Tag data in process .

From its name we can see that it is an excellent garbage collector , The main advantages ： Concurrent collection 、 Low pause . But it has the following obvious disadvantages ：

1. Yes CPU Resource sensitive （ Will compete with services for resources ）;

2. Unable to deal with Floating garbage ( In the concurrency marking and concurrency cleaning phase, garbage is generated again , This floating garbage can only wait until the next time gc Clean up again );

3. It uses a recycling algorithm -“ Mark - eliminate ” Algorithm This will cause a problem at the end of the collection A lot of space debris produce , Of course, through parameters -

XX:+UseCMSCompactAtFullCollection It can make jvm Clean up after the mark is cleared .

4. Uncertainty in execution , There will be a problem that the last garbage collection hasn't finished yet , Then garbage collection is triggered again , Especially in and During the marking and concurrent cleanup phases , While recycling , While the system is running , Maybe trigger again before recycling full gc, That is to say "concurrent mode failure", At this point, you will enter stop the world, use serial old Garbage collector to recycle

CMS Related core parameters of

1. -XX:+UseConcMarkSweepGC： Enable cms

2. -XX:ConcGCThreads： concurrent GC Number of threads

3. -XX:+UseCMSCompactAtFullCollection：FullGC Then do compression and finishing （ Reduce debris ）

4. -XX:CMSFullGCsBeforeCompaction： How many times FullGC Then compress once , The default is 0, For every time FullGC It will compress once

5. -XX:CMSInitiatingOccupancyFraction: Triggered when old age usage reaches this ratio FullGC（ The default is 92, This is the percentage ）

6. -XX:+UseCMSInitiatingOccupancyOnly： Use only the set recovery threshold (-XX:CMSInitiatingOccupancyFraction Set value ), If you don't specify ,JVM Only use the set value for the first time , Later, it will automatically adjust

7. -XX:+CMSScavengeBeforeRemark： stay CMS GC Start once before minor gc, The aim is to reduce the old age's references to the young , Reduce CMS GC The cost of marking the stage , commonly CMS Of GC Time consuming 80% It's all in the marking phase

8. -XX:+CMSParallellnitialMarkEnabled： Indicates multithreading at the time of initial marking , To shorten the STW

9. -XX:+CMSParallelRemarkEnabled： Multithreading during retargeting , To shorten the STW;

7、 ... and 、 Garbage collection underlying algorithm implementation

Tri-colour marking

In the process of concurrent tagging , Because the application thread continues to run during marking , References between objects can change , Multi label and Missing mark It is possible that .

Gcroots Reachability analysis objects encountered in traversing objects , according to “ Have you ever visited ” This condition is marked in the following three colors ：

black ： Indicates that the object has been accessed by the garbage collector , And all references to this object have been scanned . The black object represents that it has been scanned , It's safe to live , If there are other object references pointing to black objects , No need to scan again . Black objects can't be direct （ Without going through the gray object ） Point to a white object .

gray ： Indicates that the object has been accessed by the garbage collector , But at least one reference on this object has not been scanned .

white ： Indicates that the object has not been accessed by the garbage collector . Obviously at the beginning of accessibility analysis , All the objects are white , If at the end of the analysis , Still a white object , That is to say, it's impossible .

  Multi label - Floating garbage

    Multiple tags are only used in the garbage collection process because the worker thread is executing concurrently , A condition that causes a garbage object to be marked as a non garbage object , Floating garbage generated due to multi-target can only be used next time GC It's time to recycle . Multi tagging occurs during concurrent tagging and concurrent cleanup , There are two situations ： One 、 Objects that have been scanned and marked as non garbage are released as garbage at this stage , In this case, it will be treated as a non garbage object . Two 、 New objects are generated , It will also be treated as a non garbage object .

Missing mark - Read write barrier

    Missing labels will cause non garbage objects to be recycled as garbage objects , Belong to serious bug. There are two ways to do this ：

Incremental updating ： A black object adds a reference to a white object , Then add this reference to a collection , At the same time, black objects become gray objects . In the relabeling phase , The gray objects will be rescanned .

Original snapshot ： When the reference of a gray object to a white object is deleted , This reference relationship is also stored in a collection . In the relabeling phase , The white object will be found according to the reference relationship , At the same time, change the white object to the black object , Avoid being recycled as garbage . Of course , This process may also produce floating garbage .

Incremental update and original snapshot are two ways to deal with missing targets , Generally, there is only one way in the garbage collector . They are all implemented through the write barrier . The so-called writing barrier , Before and after the assignment operation , Add some processing . For example, when adding a reference, the post write barrier record is used after the reference is completed , Use pre write barrier records before deleting references .

For the read-write barrier , With Java HotSpot VM For example , When concurrent marking, the processing scheme of missing label is as follows ：

CMS： Write barriers + Incremental updating

G1,Shenandoah： Write barriers + SATB

ZGC： Reading barrier

The project is being implemented , The read-write barrier has other functions , For example, the write barrier can be used to record cross generational / Changes in zone references , Read barrier can be used to support concurrent execution of moving objects . Besides the function , And performance considerations , So for which one to choose , Every garbage collector has its own idea .

Why? G1 use SATB？CMS Update... Incrementally ？

I understand it ：SATB Relative incremental update efficiency will be high ( Of course SATB It could create more floating garbage ), Because there is no need to deep scan the deleted reference object again in the relabeling phase , and CMS The root object of the incremental reference is scanned in depth ,G1 Because a lot of objects are in different region,CMS Just an old age area , Re deep scan the object G1 It will cost more than CMS high , therefore G1 choice SATB Don't deep scan objects , It's just a simple marker , Wait until the next round GC Deep scan again .

Memory sets and card tables

    Doing it minor GC when , Because the older generation may refer to the younger generation （ This probability is very small, but it will exist ）, As a result, when dealing with such objects, you must not look for the reference relationship between them in the old age , If you scan the old age completely , Then lose it minor GC The meaning of , therefore , To deal with this situation , The younger generation uses a memory set to record the information of the part of the older generation where there are references to the objects of the younger generation . stay minor GC This part of the area in the elderly generation is directly scanned , To improve efficiency .

    To put it bluntly , Memory set is Record the collection of pointers from the non collection area to the collection area A byte array of . In fact, it's not just the new generation 、 It's only in the old days that we have the problem of cross generational quotation , All involved part of the area collection （Partial GC） Behavior of the garbage collector , A typical such as G1、 ZGC and Shenandoah The collector , They all face the same problems .

In the garbage collection scene , The collector only needs to judge whether there is a pointer to the collection area in a non collection area through the memory set , You don't need to know all the details of cross generation reference pointers .hotspot Use a method called “ Card table ”(cardtable) The way to realize memory set , It's also the most commonly used way at present . About the relationship between card table and memory set , The analogy is Java In language HashMap And Map The relationship between . The card table is implemented with a byte array ：CARD_TABLE[ ], Each element corresponds to the memory area it identifies, a memory block of a specific size , be called “ Card page ”. That is, the old age is divided into several card pages , The younger generation records the information of each card page , If an object in the older generation refers to an object of the younger generation , Update the card page status of the object in this old age to dity.mimor GC Only the scanning status is dity The old age area .

Maintenance of card meter

The card watch is dirty. It says , But you need to know how to make the card dirty , When the reference field assignment occurs , How to update the ID of card table to 1.

Hotspot Use Write barriers Maintain card table status .

Why don't the old age maintain the reference information of the young generation ？

    because full GC The whole heap will be recycled .