Shulou(Shulou.com)06/02 Report--

This article mainly introduces "what is JVM garbage collection". In daily operation, I believe many people have doubts about what is JVM garbage collection. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful to answer the doubts about "what is JVM garbage collection"! Next, please follow the editor to study!

In general, when we write java programs, we seem to pay little attention to memory allocation and garbage collection. Because, this part of the work, JVM has helped us to automatically implement.

In this way, it seems beautiful, but everything has two sides. Although JVM automatically collects garbage, what if there are some problems that JVM can't handle on its own?

Therefore, we need to understand how JVM garbage collection works so that we can be targeted when we encounter problems. So, let's talk about JVM's garbage collection today.

First of all, think about why garbage collection is needed.

We know that when you create an object, Java puts the contents of the object in the heap. Over time, there will certainly be more and more objects in the heap, but there is a limit to the size of the heap. If we don't garbage collect, that is, clear and recycle useless objects, then JVM will be overwhelmed and eventually lead to memory leaks.

Since we need to carry out garbage collection, we need to know what garbage is first.

Before the garbage collector collects heap memory, it determines which objects are still "alive" and which objects are "dead" (that is, objects that can no longer be used in any way). It's the garbage we need to collect.

So, how to determine whether it is rubbish or not? (that is, to determine whether the object is alive)

Reference counting algorithm (eliminated)

The reference counting algorithm refers to adding a reference counter to an object. Whenever there is a place to reference it, the value of the counter increases by 1, and when the reference expires, the value of the counter is subtracted by 1. When the counter value is 0, the object is recycled.

It can be said that the implementation of the reference counting algorithm is very simple and the decision efficiency is also very high. However, we overlooked the problem that in Java, objects can refer to each other circularly. If two objects circulate references to each other, the reference count between them is not zero (both are waiting for the other to release resources), so it is impossible to tell the garbage collector to reclaim them.

Reachability analysis algorithm

The idea of this algorithm is that through a series of objects called "GC Roots" as the starting point, and then search down, the path taken is called the reference chain. When there is no reference chain between an object and GC Roots (that is, from GC Roots to the object is unreachable), the object is proved to be unavailable.

This algorithm solves the problem of circular reference, as long as the object cannot establish a direct or indirect connection with the GC Root, it will be determined to be recyclable.

So, what object can be used as a GC Root? Generally divided into the following four categories:

The object referenced in the virtual machine stack (the local variable table in the stack frame).

The object referenced by the class static property in the method area.

An object referenced by a constant in the method area.

The object referenced in the local method stack.

Now that you've determined which garbage can be collected, you need a garbage collector for garbage collection. Let's take a look at some of the more common garbage collection algorithms.

Label removal algorithm

Is the most basic collection algorithm, which is divided into two stages: marking and clearing. First, mark the objects that need to be recycled, and then get rid of them. As shown in the figure above, all recyclable objects become unused areas.

The label removal algorithm has clear logic and is easy to operate. However, we can see that unused memory blocks are not contiguous, so this algorithm produces a lot of memory fragmentation. In this way, when some larger objects need to allocate space, there is not enough contiguous memory to store, so GC is triggered in advance and a lot of memory space is wasted (the memory space is too small to be available).

Replication algorithm

Replication algorithm means that the memory area is divided into two areas of equal size. Use only one piece of memory at a time, and when this piece of memory is used up, copy all the surviving objects to another piece, and finally clean up the used memory space at once.

In this way, the continuity of the memory area can be ensured, the memory fragmentation will not be generated, the implementation is simple, and the operation is efficient. However, in this way, only half of the original memory is used, and the cost is too high.

Tag finishing algorithm

Tag collation algorithm, the tag process is the same as the tag removal algorithm, but the subsequent is not to clear, but first to clean up, so that all living objects are moved to one end, and then clear the memory area at the other end.

The tag destructing algorithm not only solves the problem of memory fragmentation caused by the tag removal algorithm, but also solves the problem that the replication algorithm can only use half of the memory, which seems to be very perfect. However, it creates another problem. As you can see in the figure, the memory changes very frequently, and the memory addresses of many living objects change each time. Therefore, its efficiency will be much slower.

Therefore, generational collection algorithms are generally used now. In the Java heap, it is divided into the new generation and the old age, according to the characteristics of each generation, we can choose the most appropriate collection algorithm. In the new generation, a large number of objects die in each garbage collection, and only a small number of objects survive, so we can choose the replication algorithm, which only needs to pay a small amount of replication cost of surviving objects. In the old days, the survival rate of objects was high, and there was no extra space to allocate guarantees for it, so tag removal or tag collation algorithms were used.

Heap memory model

The Java heap is the largest area in memory management and a key area for garbage collection. The reactor is divided into Cenozoic, old age and permanent generation, Cenozoic is divided into Eden region and Survivor region, Survivor is divided into S0 and S1 region. Remove the permanent generation after JDK1.8 and replace it with metaspace. (the permanent generation uses heap memory, while metaspace uses native physical memory directly)

98% of the objects in the new generation die overnight, so the new generation is divided into a larger Eden space and two smaller Survivor spaces, using Eden and one of the Survivor each time (here the Survivor area is also called the From area, and the other empty unused space is called the to area, and the From and To areas are exchanged to ensure that the empty ones are always To areas).

When there is not enough space in the Eden area, most of the objects in the Minor GC,Eden area are reclaimed, and the surviving objects in the Eden area and the From area are put into the To area, and then the From and To areas are exchanged. (if there is not enough space in the To area, go straight to the old age)

The following situations will enter the old age.

1) large object

Large objects are objects that require a lot of contiguous memory space, most typically long strings and arrays. Large objects will go directly into the old era, and the main purpose of this is to avoid a large amount of memory replication in the new generation (large objects are expensive to copy).

2) long-term surviving objects

The virtual machine defines an object age counter for each object. Every time a Minor GC is performed, the age increases by 1 year, and when the age exceeds a certain value (the default is 15, which can be configured through parameters), it enters the old age.

3) Age judgment of dynamic objects.

Virtual machines do not require objects to reach the age of 15 to enter the old age. If the total size of all objects of the same age in the Survivor space is more than half of the Survivor space, the objects older than or equal to that age will directly enter the old age.

Space allocation guarantee

Before the occurrence of Minor GC, the virtual machine checks to see if the largest contiguous space available in the old era is larger than the total space of all objects in the new generation, and if so, the Minor GC can ensure that it is safe (because, in extreme cases, even if all the objects in the new generation survive, it can be safely promoted to the old age). Otherwise, the virtual machine checks to see if the value of HandlePromotionFailure allows the guarantee to fail. If allowed, it will continue to check whether the maximum contiguous space available in the old age is greater than the average size of the object promoted to the old age. If it is greater than that, an Minor GC will be attempted (although risky); if it is less than or the HandlePromotionFailure setting does not allow risk, then Full GC will be done first.

The above is risky because taking the average of previous promotions to the old age is only an empirical value, and there is no guarantee of success every time. If the guarantee is successful, if the guarantee fails, Full GC is still needed.

Still, it's best to turn on the HandlePromotionFailure switch to avoid too much frequent Full GC (because Full GC is much slower than Minor GC).

At this point, the study on "what is JVM garbage collection" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.