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

This article will explain in detail the problems faced by garbage collection in JVM tuning. The content of the article is of high quality, so the editor will share it with you for reference. I hope you will have some understanding of the relevant knowledge after reading this article.

How to distinguish garbage

The "reference counting" method mentioned above is judged by statistically controlling the number of references when the object is generated and deleted. The garbage collector collects objects with a count of 0. But this approach does not solve circular references. Therefore, in the later implementation of the garbage judgment algorithm, all start from the root node of the program, traversing the entire object reference to find the living object. So where does garbage collection begin in this way of implementation? That is, where to start to find which objects are being used by the current system. The difference between the stack and the stack analyzed above, where the stack is actually where the program is executed, so to get which objects are being used, you need to start with the Java stack. At the same time, a stack corresponds to a thread, so if there are multiple threads, all stacks corresponding to those threads must be checked.

At the same time, in addition to the stack, there are also registers when the system is running, which also stores the running data of the program. In this way, with the references in the stack or register as the starting point, we can find the objects in the heap and find references to other objects in the heap from these objects. This reference gradually expands and ends with null references or basic types, thus forming an object tree with the corresponding object in the Java stack as the root node. If there are multiple references in the stack, multiple object trees will eventually be formed. The objects on these object trees are all objects needed by the current system and cannot be garbage collected. Other remaining objects can be regarded as objects that cannot be referenced and can be recycled as garbage.

Therefore, the starting point for garbage collection is some root objects (java stack, static variables, registers...). The simplest Java stack is the main function that the Java program executes. This kind of recycling is also the "mark-clear" recycling method mentioned above.

How to deal with fragments

Because the survival time of different Java objects is not certain, if the program is not demarcated for a period of time, there will be scattered memory fragments. The most immediate problem with fragmentation is that large chunks of memory cannot be allocated and programs run inefficiently. Therefore, in the basic garbage collection algorithms mentioned above, both the "copy" mode and the "mark-clean" mode can solve the problem of fragmentation.

How to solve the simultaneous problems of object creation and object collection

From this point of view, the garbage collection thread reclaims memory, while the program running thread consumes (or allocates) memory, one reclaiming memory and the other allocating memory. Therefore, in the existing garbage collection methods, before garbage collection, it is generally necessary to pause the whole application (that is, pause the allocation of memory), and then carry out garbage collection, and then continue to apply after the collection is completed. This kind of realization is the most direct and effective way to solve the contradiction between the two.

However, this approach has an obvious drawback, that is, when the heap space continues to increase, the garbage collection time will continue to increase, and the corresponding application pause time will also increase accordingly. For some applications that require high time, such as a few hundred milliseconds for pause time, this limit is likely to be exceeded when the heap space is greater than a few gigabytes. Garbage collection will become a bottleneck in the operation of the system. In order to solve this contradiction, there is a concurrent garbage collection algorithm, using this algorithm, the garbage collection thread and the program running thread run at the same time. In this way, the problem of pause is solved, but because the object needs to be reclaimed while the newly generated object is generated, the complexity of the algorithm will be greatly increased, and the processing capacity of the system will be reduced accordingly. At the same time, the problem of "fragmentation" will be more difficult to solve.

On JVM tuning garbage collection problems are shared here, I hope the above content can be of some help to you, can learn more knowledge. If you think the article is good, you can share it for more people to see.

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.