StringTable Detailed String Pool Performance Tuning String Concatenation

1. Composition:

2. The relationship between the constant pool and the string pool:

The constant pool originally exists in the bytecode file. When running, the information in the constant pool will be loaded into the runtime constant pool. At this time, a, b, and ab are all symbols in the constant pool, and there is no changeinto a java string object, when it is executed to the line of code that references him, the a symbol will be turned into an object, and a space for the StringTable string pool will be prepared at the same time, and the generated object "a" will be used as the key.Find it in the pool, if not, put the newly generated object a into the string pool.(Note: each string object is only put into the string pool when this sentence is executed, not in advance)

The data structure of StringTable is hashtable, which has a fixed length and cannot be expanded.

3. String variable concatenation

eg: the following example is false

s3 is in the string pool, and s4 is the spliced ​​ab. Under the action of toString, the spliced ​​data is turned into a new string, which exists in the heap, which is equivalent to new String ("ab")

The following is the source code of toString

eg: The following example is true

s5 is because of the optimization of javac during compilation, it will consider "a" and "b" to be constants, and the splicing result is determined. The result has been determined as ab at compile time and will not change, so it is put into the string pool.The previous one is a variable, and its value may be modified at runtime, so it needs to be spliced ​​with SringBuilder at runtime.

Lines 6 and 29 both find a symbol with a value of ab at position 4 in the constant pool, so when s3 is executed, it is found that there is no such object in the string pool, and the ab object is created according to the ab symbol, it will be put into the string pool, and when the execution reaches s5, the ab symbol will be found at position 4, so no new objects will be created, and the objects in the string pool will be used directly.

Only constant strings are stored in the string pool.

4.Characteristics of StringTable:

1. The strings in the constant pool are only symbols, and will become objects when they are used for the first time

2. Use the mechanism of string pool to avoid repeated creation of string objects

3. The principle of string variable splicing is StringBuilder (jdk1.8)

4. The principle of string constant concatenation is compile-time optimization

5. You can use the intern method to actively put the string objects that are not yet in the string pool into the string pool, and put the address (if there is one in 1.8, it will not be put in, if not, it will be put directly, regardless of whether it is there or not.All directly return the object value in the string pool. In 1.6, if there is one, it will not be put in, if not, a copy will be assigned and put in, and the object value in the string pool will be returned directly regardless of whether there is or not.)

Example:

If the position is changed as follows: x2 is successfully entered into the pool, but also exists in the heap at the same time

Version 1.6:

5. Location of StringTable

StringTable garbage collection:

StringTable will also be garbage collected, and garbage collection will occur when the memory is not very sufficient.

5.StringTable performance tuning

Two considerations:

①Mainly adjust the number of hashtable buckets,

The larger the number of buckets, the faster the operation will be.There will be better hash distribution and reduce hash conflicts

You can use -XX:StringTableSize=Number of buckets to adjust

②Consider whether to put the string object into the pool. After entering the pool, it will take up much less memory