Detailed explanation of memory leak caused by substring method in Java

Out of memory: Generally speaking, there is not enough memory. For example, creating a large object in an infinite loop will soon lead to memory overflow.

Leak of memory: after allocating memory for an object, it is not released in time when the object is no longer in use, resulting in occupying the memory unit all the time and reducing the actual available memory, just like a memory leak.

@H_ 301_ 5 @ memory leak caused by substring method

Substring (int beginindex, int endndex) is a method of string class, but the implementation of this method in JDK6 and JDK7 is completely different (although they both achieve the same effect). Understanding the differences in their implementation details can better help you use them, because improper use of substring in JDK1.6 will lead to serious memory leakage problems.

@H_ 301_ 5@1 Function of substring

Substring (int beginindex, int endindex) method returns a substring, starting from the beginindex of the parent string and ending at endindex-1. The subscript of the parent string starts at 0, and the child string contains beginindex instead of endindex

The output of the above program is "BC"

@H_ 301_ 5@2 I. implementation principle

The string class is immutable. When x is re assigned in the second sentence above, it will point to a new string object. However, it does not accurately describe or represent the actual situation in the heap. What really happens when substring is called is the difference between the two.

Substring implementation in JDK6

The string object is stored as a char array. In the string class, there are three fields: char [] value, int offset and int count, which are used to store the real character array, the starting position of the array and the number of characters of the string. These three variables can determine a string. When the substring method is called, it will create a new string, but the above char array value will still use the value of the original parent array. The only difference between the parent array and the child array is that the values of count and offset are different.

Take a look at the implementation source code of substring in JDK6:

This simple program has two string variables STR and sub. The sub string is intercepted by the parent string STR, if the above program is in jdk1 Running in 6, we know that the memory space allocation of the array is carried out on the heap, so the internal char array value of sub and STR share the same, that is, the char array composed of character a ~ character T. The only difference between STR and sub is the difference between beginindex and character length count in the array. In the third sentence, we leave the str reference empty, which is intended to free up the space occupied by STR, but at this time, GC cannot recycle the large char array because it is still referenced inside the sub string, although sub intercepts only a small part of the large array. When STR is a very large string, this waste is very obvious, and even brings performance problems. The following methods can be used to solve this problem:

The string splicing technology is used. It will create a new string. This new string will use a new internal char array to store the characters it actually needs. In this way, the char array of the parent array will not be referenced by others, making STR = null. The space occupied by the whole str will be recycled in the next GC recycling. But this writing is obviously not good-looking, so substring is re implemented in JDK7.

@H_ 301_ 5@JDK7 Substring implementation in

The implementation of substring is improved in JDK7. It actually creates a new char array in the heap for the intercepted substring to save the characters of the substring.

Check the implementation source code of substring method of string class in JDK7:

Copyofrange method of arrays class:

It can be found that a new char array is created for the substring to store the characters in the substring. In this way, there is no inevitable relationship between the child string and the parent string. When the reference of the parent string fails, GC will timely recover the memory space occupied by the parent string.

@H_ 301_ 5 @ summary

The above is all about the detailed explanation of memory leakage caused by substring method in Java. I hope it will be helpful to you. Interested friends can continue to refer to other related topics on this site. If there are deficiencies, please leave a message to point out. Thank you for your support!