Eingehende Analyse des Verständnisses und der Rolle des String-Konstanten-Pools und Puffer-Pools in JAVA

Dieser Artikel vermittelt Ihnen relevantes Wissen über Java, das hauptsächlich das Verständnis und die Rolle von String-Konstanten-Pool und Puffer-Pool vorstellt. String-Pool und Konstanten-Pool sind zwei völlig unterschiedliche Dinge, aber an vielen Stellen verwechseln sie sie alle gerne, was kann bei Anfängern leicht zu Missverständnissen führen. Ich möchte sie hier ausführlich besprechen und hoffe, allen zu helfen.

Empfohlene Studie: „Java Learning Tutorial“

String-Pool kann auch „String-Konstanten-Pool“ genannt werden string

werden weggelassen, so dass nur constant pool übrig bleibt... Um Missverständnisse zu vermeiden, schlage ich vor, dass Sie den Cache-Pool von String-Objekten einfach string pool 1 Pool nennen.

1.1 Statischer Konstantenpool

Der Konstantenpool in der .class-Datei kann als Array betrachtet werden. Wenn diese Konstante in Bytecode-Anweisungen verwendet werden muss Kommt vorbei und besichtigt es. Schauen Sie sich den Code unten an:

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

Er wird in der folgenden Form im Bytecode vorliegen:

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

Natürlich ist dies nur eine vereinfachte Version, sie ist tatsächlich komplizierter (die tatsächliche Version finden Sie in der Verweise am Ende des Artikels Für die in diesem Abschnitt veröffentlichte Antwort können Sie vorerst nur die vereinfachte Version in Betracht ziehen)Beachten Sie, dass die darin gespeicherte String-Konstante nur eine einfache UTF8-codierte Bytesequenz und kein Java-String-Objekt ist Genau wie die Zeichenfolge, die Sie in einem TXT-Text speichern, verwenden wir das UTF8-Format, um eine .class-Datei zu öffnen. Sie können sehen, dass hellohellohello analysiert werden kann:

1.2 Runtime Constant Pool

Verstehen Nach dem Verständnis Statischer Konstantenpool, der Laufzeitkonstantenpool ist leicht zu verstehen. Einfach ausgedrückt ist der Laufzeitkonstantenpool die Laufzeitdarstellung des statischen Konstantenpools in der .class-Datei in der JVM. Jeder statische Konstantenpool in der .class-Datei generiert einen entsprechenden Laufzeitkonstantenpool. Wenn die JVM die Anweisung String m = #1 interpretiert, kann sie zum Laufzeitkonstantenpool dieser Klasse gehen, um die Definition von #1 zu finden.

2 String-Pool

Der String-Pool ist ein von Java eingerichteter Cache-Pool zur Wiederverwendung von String-Objekten. Vor Java1.7 wurde er im Methodenbereich festgelegt und String-Objekte gespeichert Es wird dann auf den Heap gesetzt und enthält einen Verweis auf das String-Objekt. Das String-Objekt selbst existiert an anderer Stelle auf dem Heap. Im Folgenden wird die Situation nach Java 1.7 als Standard verwendet. hellohellohellohellohello是可以被解析的：

1.2 运行时常量池

理解了静态的常量池之后，运行时常量池就很容易想明白了。简单来说，运行时常量池就是.class文件中的静态常量池在JVM中的运行时表示，每一个.class文件的静态常量池都会生成一个对应的运行时常量池。等到JVM在解释String m = #1这条指令时，它可以去这个类的运行时常量池中查找#1的定义。

2 字符串池

字符串池是Java为了重用String对象而设置的一个缓存池，Java1.7之前设置在方法区上，保存的是String对象；Java1.7之后设置在堆上，保存的是String对象的引用，String对象本身存在于堆上的其他位置。下文中以Java1.7之后的情况为标准。

继续上面的例子。当JVM在解释String m = #1时，它已经从运行时常量池拿到了相应的UTF8序列，接下来，它会在字符串池中寻找和这个UTF8序列对应的String对象，并把这个对象的引用赋值给m。你可能会好奇这个String被创建的时机，根据R大的这篇文章，在这条语句所在的类被加载时，如果字符串池中已经存在对应的对象了，那么就什么都不做，如果不存在，就会创建一个对应的String对象，并把其引用放入池中。

除了字符串池，Integer、Long等Wrapper类型也有自己的缓存池，比如Integer会缓存从-128~127的Integer对象，当使用字面量赋值或者Integer.valueOf()

Fahren Sie mit dem obigen Beispiel fort. Wenn die JVM String m = #1 interpretiert, hat sie die entsprechende UTF8-Sequenz aus dem Laufzeitkonstantenpool abgerufen. Als Nächstes sucht sie im String-Pool nach dem String-Objekt, das dieser UTF8-Sequenz entspricht, und fügt die Referenz des Objekts hinzu zugeordnet zu m. Sie sind möglicherweise neugierig auf den Zeitpunkt, zu dem dieser String erstellt wird. Wenn die Klasse, in der sich diese Anweisung befindet, geladen wird, wird nichts unternommen, wenn das entsprechende Objekt bereits im String-Pool vorhanden ist nicht existiert, wird ein entsprechendes String-Objekt erstellt und dessen Referenz im Pool platziert.

Zusätzlich zum String-Pool verfügen Wrapper-Typen wie Integer und Long auch über eigene Cache-Pools. Beispielsweise wird Integer zwischengespeichert Werte von -128~127 Integer Objekt, bei Verwendung von Literalzuweisung oder Integer.valueOf(), wenn das entsprechende Objekt im Pool vorhanden ist, das Objekt im Pool wird nur zurückgegeben, wenn der Pool neue Objekte nur dann auf dem Heap erstellt, wenn keine vorhanden sind.

Im Gegensatz zum String-Pool wachsen diese Wrapper-Pools jedoch nicht wie der String-Pool, d. h. die Anzahl der Objekte im Pool ist festgelegt, und im Integer-Pool sind nur -128 bis 127 vorhanden.

Der dem Grundtyp entsprechende Pufferpool lautet wie folgt:

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

Unter allen numerischen Pufferpools in JDK 1.8 ist der Integer-Pufferpool IntegerCache etwas ganz Besonderes. Die Untergrenze dieses Pufferpools beträgt -128 und die Obergrenze Die Grenze beträgt standardmäßig 127, aber diese Obergrenze ist einstellbar. Geben Sie beim Starten des JVM die Größe dieses Pufferpools über -XX:AutoBoxCacheMax= an Die JVM wird initialisiert. Wenn IntegerCache initialisiert wird, wird diese Systemeigenschaft gelesen, um die Obergrenze zu bestimmen.

Empfohlenes Lernen: „🎜Java-Tutorial🎜“🎜

Das obige ist der detaillierte Inhalt vonEingehende Analyse des Verständnisses und der Rolle des String-Konstanten-Pools und Puffer-Pools in JAVA. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!