Analyse approfondie de la compréhension et du rôle du pool de constantes de chaîne et du pool de tampons en JAVA

Cet article vous apporte des connaissances pertinentes sur java, qui présente principalement la compréhension et le rôle du pool de constantes de chaînes et du pool de tampons sont deux choses complètement différentes, mais dans de nombreux endroits, ils aiment tous les confondre. peuvent facilement provoquer des malentendus parmi les débutants. J'aimerais ici en discuter attentivement, dans l'espoir d'aider tout le monde.

Étude recommandée : "Tutoriel d'apprentissage Java"

Le pool de cordes peut aussi être appelé Le pool constant de cordes Je pense que ce nom est la source d'un malentendu. Certaines personnes en parlent simplement. string sont omis, ne laissant que pool constant... Donc, afin d'éviter tout malentendu, je suggère que lorsque l'on fait référence au pool de cache d'objets chaîne, il suffit de l'appeler pool de chaînes 1 Pool

.

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 hellohellohellohellohello peut être analysé :

1.2 Pool de constantes d'exécution

Compréhension 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.

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()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. à 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.

🎜🎜🎜Apprentissage recommandé : "🎜Tutoriel Java🎜"🎜

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!