In-depth analysis of the understanding and role of string constant pool and buffer pool in JAVA

This article brings you relevant knowledge about java, which mainly introduces the understanding and role of string constant pool and buffer pool. String pool and constant pool are completely different. There are two things, but many places like to confuse them, which can easily cause misunderstandings among beginners. Here I would like to discuss them carefully, hoping to help everyone.

Recommended study: "java Learning Tutorial"

String pool can also be calledString constant pool , I think this name is the source of misunderstanding. Some people omit the three words string, leaving only constant pool.. . So in order to avoid misunderstanding, I suggest that when referring to the cache pool of string objects, just call it String pool

1 Constant pool

Constant The pool is divided into two types, one is the static constant pool in the .class file, and the other is the runtime constant pool# formed by loading the static constant pool in the .class file into the JVM. ##.

1.1 Static constant pool

The constant pool in the .class file can be regarded as an array. Some constants are stored in the array. When needed in the bytecode instructions When this constant is used, it is accessed through the index of the array.

Look at the following code:

 String m = "hellohellohellohellohello";
 String n = "hellohellohellohellohello";

It will look like this in the bytecode:

 // 常量池：
 #1 hellohellohellohellohello
 #2 ...
 ...
 ----------------------------
 
 String m = #1;
 String n = #1;

Of course, this is just a simplified version, in fact More complicated (for the actual version, you can see the answer posted in the reference section at the end of the article. For now, you can only consider the simplified version)

Note that the string constant stored in this is just a simple UTF8 An encoded byte sequence, not a Java string object. It is the same as the string you store in a txt text. We use UTF8 format to open a .class file and you can see

hellohellohellohellohello It can be parsed:

1.2 Runtime constant pool

After understanding the static constant pool, the runtime constant pool is easy to understand. . Simply put, the runtime constant pool is the runtime representation of the static constant pool in the .class file in the JVM. Each static constant pool in the .class file will generate a corresponding runtime constant pool. When the JVM interprets the instruction

String m = #1, it can go to the runtime constant pool of this class to find the definition of #1.

2 String pool

The string pool is a cache pool set up by Java to reuse the

String object. It was set in the method area before Java 1.7 and saved It is a String object; it is set on the heap after Java 1.7 and saves a reference to the String object. The String object itself exists elsewhere on the heap. The following takes the situation after Java 1.7 as the standard.

Continue with the above example. When the JVM is interpreting String m = #1, it has obtained the corresponding UTF8 sequence from the runtime constant pool. Next, it will look for the String object corresponding to this UTF8 sequence in the string pool, and add the object's The reference is assigned to m. You may be curious about the timing when this String is created. According to this R article, when the class where this statement is located is loaded, if the corresponding object already exists in the string pool, then nothing will be done. If If it does not exist, a corresponding String object will be created and its reference will be placed in the pool.

In addition to the string pool, Wrapper types such as

Integer and Long also have their own cache pools. For example, Integer will cache from -128~127 The Integer object, when using literal assignment or Integer.valueOf(), if the corresponding object exists in the pool, the object in the pool will be returned. Only when there is no such object in the pool Only then will new objects be created on the heap.

However, unlike the string pool, these Wrapper pools will not grow like the string pool, that is, the number of objects in the pool is fixed, and there will only be -128~127 in the Integer pool. .

The buffer pool corresponding to the basic type is as follows:

boolean values true and false
 all byte values
 short values between -128 and 127
 int values between -128 and 127
 char in the range \u0000 to \u007F

Among all the numerical buffer pools in jdk 1.8, the Integer buffer pool IntegerCache is very special. The lower bound of this buffer pool is - 128, upper The default limit is 127, but this upper limit is adjustable. When starting the jvm, specify the size of this buffer pool through -XX:AutoBoxCacheMax=. This option will set a file named java.lang when the JVM is initialized. .IntegerCache.high system property, and then when IntegerCache is initialized, it will read the system property to determine the upper bound.

Recommended study: "

java tutorial"

The above is the detailed content of In-depth analysis of the understanding and role of string constant pool and buffer pool in JAVA. For more information, please follow other related articles on the PHP Chinese website!