jvm garbage collection algorithm

We all know that the biggest difference between Java language and C language is automatic memory recycling. So how does JVM control memory recycling? This article will introduce several algorithms of JVM garbage collection to understand the basics of memory recycling. principle.

stop the world

Before introducing the garbage collection algorithm, we need to first understand the word "stop the world", stop the world will Occurs when executing a certain garbage collection algorithm. In order to perform garbage collection, the JVM will temporarily execute the Java application and wait until the garbage collection is completed before continuing to run. If you have used JMeter to test a Java program, you may find that during the test, the Java program has irregular pauses. In fact, this is "stop the world". During the pause, the JVM is doing garbage collection. Therefore, reducing the time to stop the world as much as possible is our main goal in optimizing the JVM. Next, let’s take a look at what common garbage collection algorithms are currently available.

Reference counting method

The reference counting method, as the name suggests, counts the number of times an object is referenced. When a reference count is increased, the reference counting method is increased. 1. Decrementing the reference count by one reduces it by 1.

The above figure shows that three Teacher references point to the Teacher object in the heap, then the reference count of the Teacher object is 3 , and so on, the reference count of the Student object is 2.

##The above figure shows that the reference of the Teacher object is reduced to 2. The reference of the Student object is reduced to 0 (the reason for the reduction is that the reference points to null, such as teacher3=null). According to the reference counting algorithm, the memory space of the Student object will be reclaimed.

The principle of the reference counting algorithm is very simple. It is the most primitive recycling algorithm, but this algorithm is not used in Java. There are 2 reasons. 1. Frequent counting affects performance, and 2. Unable to handle circular reference issues.

For example, the Teacher object references the Student object, and the Student object references the Teacher object. In this case, the object will never be recycled.

Mark clearing

Mark clearing algorithm, which is the basis of many garbage collection algorithms. Simply put, there are two steps: marking and clearing .

Mark: Traverse all GC Roots and set objects reachable from GC Roots as living objects;

Clear: Traverse the heap All objects in , objects that are not marked as reachable will be cleared;

Pay attention to the gray objects in the above picture, because They cannot be traversed from the GC Root (although they themselves have reference relationships, they cannot be traversed from the GC Root), so they are not marked as alive objects and will be recycled during the cleanup process.

It should be noted here that during the execution of the mark clearing algorithm, "stop the world" will be generated, allowing the Java program to pause and wait to ensure that during the mark clearing process, there will be no new object is generated. Why must the java program be paused? For example, if a new object is generated after the marking process is completed, and the object has missed the marking period, then in the subsequent cleanup process, the newly generated object will be regarded as unmarked because it has not been marked. If the unreachable object is cleared, the program will error. Therefore, when the mark clearing algorithm is executed, the Java program will be suspended, resulting in "stop the world".

Next we summarize the mark clearing algorithm:

1. Because it involves a lot of memory traversal work, the execution performance is low. It will also lead to a longer "stop the world" time and reduced Java program throughput;

#2. We noticed that after the object is cleared, the cleared object leaves a vacancy in the memory. , causing memory discontinuity and waste of space.

Next let’s see if other algorithms can improve these problems?

Mark compression

Mark compression algorithm You may have thought of it. It is based on the mark removal algorithm and adds a compression process.

After the mark clearing is completed, the memory space is compressed to save memory space and solve the problem of mark clearing algorithm memory. Discontinuity problem.

Note that the mark compression algorithm will also produce "stop the world" and cannot be executed concurrently with the Java program. During the compression process, the memory addresses of some objects will change, and the Java program can only wait for the compression to complete before continuing.

Copy algorithm

The copy algorithm simply divides the memory into two parts, but only uses one of them during garbage collection. , copy the surviving objects in the memory being used to another blank memory, and finally clear the objects in the memory space being used to complete garbage collection.

Replication algorithm relative mark The compression algorithm is more concise and efficient, but its shortcomings are also obvious. It is not suitable for situations where there are many surviving objects, because there are many objects that need to be copied, and the copy performance is poor. Therefore, the copy algorithm is often used in the new generation in the memory space. Garbage collection, because there are fewer surviving objects in the new generation and the copy cost is lower. Another disadvantage is its high memory space occupation cost, because it copies objects based on two memory spaces, and only uses one memory space during the non-garbage collection cycle, resulting in low memory utilization.

Summary

Above we have introduced common garbage collection algorithms. Each of these algorithms has its own advantages and disadvantages, but they are not Instead of simply using a specific algorithm, you use something called a garbage collector. The garbage collector can be seen as a different combination of a series of algorithms. Only by using the appropriate garbage collector in different scenarios can you get twice the result with half the effort. . Our next article will introduce the garbage collector.

Reference materials:

"Practical Java Virtual Machine" Ge Yiming

"In-depth Understanding of Java Virtual Machine Machine (2nd Edition)》Zhou Zhiming

##

The above is the detailed content of jvm garbage collection algorithm. For more information, please follow other related articles on the PHP Chinese website!