Quel est le rôle du pool de constantes de chaîne et du pool de tampons en JAVA

1 Pool constant

Le pool constant est divisé en deux types, l'un est le pool constant statique dans le fichier .class, et l'autre est le pool constant statique dans le fichier .class qui est chargé dans la JVM. Le pool de constantes d'exécution.

1.1 Pool de constantes statiques

. Le pool de constantes dans le fichier .class peut être considéré comme un tableau. Certaines constantes sont stockées dans le tableau. Lorsque cette constante doit être utilisée dans les instructions de bytecode, l'index du tableau. est utilisé. Venez le visiter.

Regardez le code ci-dessous :

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

Il sera sous la forme de ceci dans le bytecode :

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

Bien sûr, ce n'est qu'une version simplifiée, elle est en fait plus compliquée (la version actuelle peut être trouvée dans le références à la fin de l'article Pour la réponse publiée dans la section, vous ne pouvez considérer que la version simplifiée pour l'instant)

Notez que la constante de chaîne stockée ici n'est qu'une simple séquence d'octets codée en UTF8, pas un objet chaîne Java . Tout comme la chaîne que vous stockez dans un texte txt, nous utilisons le format UTF8 pour ouvrir un fichier .class. Vous pouvez voir que hellohellohellohello peut être analysé : 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()

1.2 Pool de constantes d'exécution

Après avoir compris le pool constant statique, le pool constant d’exécution est facile à comprendre. En termes simples, le pool de constantes d'exécution est la représentation d'exécution du pool de constantes statiques dans le fichier .class de la JVM. Chaque pool de constantes statiques du fichier .class générera un pool de constantes d'exécution correspondant. Lorsque la JVM interprète l'instruction String m = #1, elle peut accéder au pool de constantes d'exécution de cette classe pour trouver la définition de #1.

2 String Pool🎜🎜Le pool de chaînes est un pool de cache mis en place par Java pour réutiliser les objets String Avant Java1.7, il était défini dans la zone de méthode et enregistré les objets String Java1.7 ; Il est ensuite défini sur le tas et contient une référence à l'objet String lui-même existe ailleurs sur le tas. Ce qui suit prend la situation après Java 1.7 comme standard. 🎜🎜Continuez avec l'exemple ci-dessus. Lorsque la JVM interprète String m = #1, elle a obtenu la séquence UTF8 correspondante du pool de constantes d'exécution. Ensuite, elle recherchera l'objet String correspondant à cette séquence UTF8 dans le pool de chaînes et ajoutera la référence de l'objet. attribué à m. Vous pourriez être curieux de connaître le moment où cette chaîne est créée. Selon cet article R, lorsque la classe où se trouve cette instruction est chargée, si l'objet correspondant existe déjà dans le pool de chaînes, alors rien ne sera fait. n'existe pas, un objet String correspondant sera créé et sa référence sera placée dans le pool. 🎜🎜En plus du pool de chaînes, les types Wrapper tels que Integer et Long ont également leurs propres pools de cache. Par exemple, Integer sera mis en cache. valeurs de -128~127 objet Integer, lors de l'utilisation d'une affectation littérale ou Integer.valueOf(), si l'objet correspondant existe dans le pool, l'objet dans le pool sera renvoyé uniquement lorsque le pool. De nouveaux objets seront créés sur le tas uniquement s'il n'y en a pas. 🎜🎜Cependant, contrairement au pool de chaînes, ces pools Wrapper ne grandiront pas comme le pool de chaînes, c'est-à-dire que le nombre d'objets dans le pool est fixe et il n'y aura que -128~127 dans le pool Integer. 🎜🎜Le pool de tampons correspondant au type de base est le suivant : 🎜

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

🎜Parmi tous les pools de tampons numériques de jdk 1.8, le pool de tampons entiers IntegerCache est très spécial. La limite inférieure de ce pool de tampons est de - 128, et la limite supérieure. la limite est de 127 par défaut, mais cette limite supérieure est réglable. Lors du démarrage de jvm, spécifiez la taille de ce pool de tampons via -XX:AutoBoxCacheMax=. Cette option définira une propriété système nommée java.lang.IntegerCache.high lorsque. la JVM est initialisée, puis lorsque IntegerCache est initialisé, cette propriété système sera lue pour déterminer la limite supérieure. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!