[JVM]了断局:常量池 VS 运行时常量池 VS 字符串常量池

今天药忘吃喽~ 2022-12-01 05:20 209阅读 0赞

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70][]

# 一.前言 #

最近在看JVM, 常量池, 运行时常量池,字符串常量池 这个看的有点懵. 整理一下.

>  *  `class常量池` 是在编译的时候每个class都有的. 在编译阶段，存放的是常量的 **符号引用** 。       \[在class文件中.\]             
>  *  `字符串常量池` 在每个VM中只有一份，存放的是字符串常量的 **引用值** 。  \[在堆中.\]                                       
>  *  `运行时常量池` 是在类加载完成之后，将每个`class常量池` 中的符号引用值转存到 `运行时常量池` 中，也就是说，每个class都有一个 `运行时常量池` ，类在 **解析阶段** ，将 符号引用 替换成 直接引用 ，与 `字符串常量池` 中的引用值保持一致。.\[在方法区.\]

关系图如下:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70 1][]

原图地址: [https://www.processon.com/view/5f45d1d9e0b34d638e07816d][https_www.processon.com_view_5f45d1d9e0b34d638e07816d]

# 二.常量池\[ class文件常量池 , 静态常量 \] #

class文件常量池是指编译生成的class字节码文件结构中的一个常量池（Constant Pool Table），用于存放编译期间生成的各种字面量和符号引用，是在class文件中存放的.  **这部分内容将在类加载后，存放于方法区的运行时常量池**。

--------------------

下面的是详情,可以不看..

常量池可以比喻为Class文件里的资源仓库， 它是Class文件结构中与其他项目关联最多的数据， 通常也是**占用Class文件空间最大**的数据项目之一， 另外， 它还是在Class文件中第一个出现的表类型数据项目.

常量池中常量的数量是不固定的，在常量池的入口有一项u2类型的数据， 代表常量池容量计数值（constant\_pool\_count） 。这个容量计数是从1而不是0开始的, 如下图所示: 常量池容量（偏移地址： 0x00000008） 为十六进制数0x0046， 即十进制的70， 这就代表常量池中有69项常量， 索引值范围为1～69。

在Class文件格式规范制定之时， 设计者将第0项常量空出来是有特殊考虑的， 这样做的目的在于， 如果后面某些指向常量池的索引值的数据在特定情况下需要表达“不引用任何一个常量池项目”的含义， 可以把索引值设置为0来表示。

**Class文件结构中只有常量池的容量计数是从1开始**， 对于其他集合类型， 包括接口索引集合、 字段表集合、 方法表集合等的容量计数都与一般习惯相同， 是从0开始。

# ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70 2][] #

**常量池中主要存放两大类常量： 字面量（Literal） 和符号引用（SymbolicReferences） 。 **

**字面量比较接近于Java语言层面的常量概念**， 如文本字符串、 被声明为final的常量值等。

**而符号引用则属于编译原理方面的概念.**

主要包括下面几类常量：

> ·被模块导出或者开放的包（Package）  
> ·类和接口的全限定名（Fully Qualified Name）  
> ·字段的名称和描述符（Descriptor）  
> ·方法的名称和描述符  
> ·方法句柄和方法类型（Method Handle、 Method Type、 Invoke Dynamic）  
> ·动态调用点和动态常量（Dynamically-Computed Call Site、 Dynamically-Computed  
> Constant）

Java代码在进行Javac编译的时候,是在虚拟机加载Class文件的时候进行动态连接.在Class文件中不会保存各个方法、 字段最终在内存中的布局信息， 这些字段、 方法的符号引用不经过虚拟机在运行期转换的话是无法得到真正的内存入口地址， 也就无法直接被虚拟机使用的。 **当虚拟机做类加载时， 将会从常量池获得对应的符号引用， 再在类创建时或运行时解析、 翻译到具体的内存地址之中。**

**常量池中每一项常量都是一个表**， 最初常量表中共有11种结构各不相同的表结构数据， 后来为了更好地支持动态语言调用， 额外增加了4种动态语言相关的常量\[1\]， 为了支持Java模块化系统（Jigsaw）, 又加入了CONSTANT\_Module\_info和CONSTANT\_Package\_info两个常量， 所以**截至JDK 13， 常量表中分别有17种不同类型的常量**。

这17类表都有一个共同的特点， 表结构起始的第一位是个u1类型的标志位,代表着当前常量属于哪种常量类型。

常量池是最烦琐的数据， 是因为这17种常量类型各自有着完全独立的数据结构， 两两之间并没有什么共性和联系.

**常量池清单:**

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>类型</th> 
   <th>标志</th> 
   <th>16进制码</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1.</td> 
   <td>CONSTANT_Utf8_info</td> 
   <td>1</td> 
   <td>01</td> 
   <td>UTF-8编码的字符串</td> 
  </tr> 
  <tr> 
   <td>2.</td> 
   <td>CONSTANT_Interger_info</td> 
   <td>3</td> 
   <td>03</td> 
   <td>整型字面量</td> 
  </tr> 
  <tr> 
   <td>3.</td> 
   <td>CONSTANT_Float_info</td> 
   <td>4</td> 
   <td>04</td> 
   <td>浮点型字面量</td> 
  </tr> 
  <tr> 
   <td>4.</td> 
   <td>CONSTANT_Long_info</td> 
   <td>5</td> 
   <td>05</td> 
   <td>长整形字面量</td> 
  </tr> 
  <tr> 
   <td>5.</td> 
   <td>CONSTANT_Double_info</td> 
   <td>6</td> 
   <td>06</td> 
   <td>双精度浮点型字面量</td> 
  </tr> 
  <tr> 
   <td>6.</td> 
   <td>CONSTANT_Class_info</td> 
   <td>7</td> 
   <td>07</td> 
   <td>类或接口的符号引用</td> 
  </tr> 
  <tr> 
   <td>7.</td> 
   <td>CONSTANT_String_info</td> 
   <td>8</td> 
   <td>08</td> 
   <td>字符串类型字面量</td> 
  </tr> 
  <tr> 
   <td>8.</td> 
   <td>CONSTANT_Fieldref_info</td> 
   <td>9</td> 
   <td>09</td> 
   <td>字段的符号引用</td> 
  </tr> 
  <tr> 
   <td>9.</td> 
   <td>CONSTANT_Methodref_info</td> 
   <td>10</td> 
   <td>0A</td> 
   <td>类中方法的符号引用</td> 
  </tr> 
  <tr> 
   <td>10.</td> 
   <td>CONSTANT_InterfaceMethodref_info</td> 
   <td>11</td> 
   <td>0B</td> 
   <td>接口方法的符号引用</td> 
  </tr> 
  <tr> 
   <td>11.</td> 
   <td>CONSTANT_NameAndType_info</td> 
   <td>12</td> 
   <td>0C</td> 
   <td>字段或方法的部分符号引用</td> 
  </tr> 
  <tr> 
   <td>12.</td> 
   <td>CONSTANT_MethodHandle_info</td> 
   <td>15</td> 
   <td>0F</td> 
   <td>表示方法句柄</td> 
  </tr> 
  <tr> 
   <td>13.</td> 
   <td>CONSTANT_MethodType_info</td> 
   <td>16</td> 
   <td>10</td> 
   <td>表示方法类型</td> 
  </tr> 
  <tr> 
   <td>14.</td> 
   <td>CONSTANT_Dynamic_info</td> 
   <td>17</td> 
   <td>11</td> 
   <td>表示一个动态计算常量</td> 
  </tr> 
  <tr> 
   <td>15.</td> 
   <td>CONSTANT_InvokeDynamic_info</td> 
   <td>18</td> 
   <td>12</td> 
   <td>表示一个动态方法调用点</td> 
  </tr> 
  <tr> 
   <td>16.</td> 
   <td>CONSTANT_Module_info</td> 
   <td>19</td> 
   <td>13</td> 
   <td>表示一个模块</td> 
  </tr> 
  <tr> 
   <td>17.</td> 
   <td>CONSTANT_Package_info</td> 
   <td>20</td> 
   <td>14</td> 
   <td>表示一个模块中开放或者导出的包</td> 
  </tr> 
 </tbody> 
</table>

常量池中的17种数据类型的结构总表

<table> 
 <thead> 
  <tr> 
   <th>常量</th> 
   <th>含义</th> 
   <th>项目</th> 
   <th>类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td colspan="1">CONSTANT_Utf8_info</td> 
   <td>UTF-8编码的字符串</td> 
   <td>tag</td> 
   <td>u1</td> 
   <td>值为1</td> 
  </tr> 
  <tr> 
   <td>length</td> 
   <td>u2</td> 
   <td>UTF-8编码的字符串占用了字节数</td> 
  </tr> 
  <tr> 
   <td>bytes</td> 
   <td>u1</td> 
   <td>长度为length的UTF-8编码的字符串</td> 
  </tr> 
  <tr> 
   <td colspan="1">CONSTANT_Interger_info</td> 
   <td>整型字面量</td> 
   <td>tag</td> 
   <td>u1</td> 
   <td>值为3</td> 
  </tr> 
  <tr> 
   <td>bytes</td> 
   <td>u4</td> 
   <td>按照高位在前存储int值</td> 
  </tr> 
  <tr> 
   <td colspan="1">CONSTANT_Float_info</td> 
   <td>浮点型字面量</td> 
   <td>tag</td> 
   <td>u1</td> 
   <td>值为4</td> 
  </tr> 
  <tr> 
   <td>bytes</td> 
   <td>u4</td> 
   <td>按照高位在前存储float值</td> 
  </tr> 
  <tr> 
   <td colspan="1">CONSTANT_Long_info</td> 
   <td>长整形字面量</td> 
   <td>tag</td> 
   <td>u1</td> 
   <td>值为5</td> 
  </tr> 
  <tr> 
   <td>bytes</td> 
   <td>u8</td> 
   <td>按照高位在前存储long值</td> 
  </tr> 
  <tr> 
   <td colspan="1">CONSTANT_Double_info</td> 
   <td>双精度浮点型字面量</td> 
   <td>tag</td> 
   <td>u1</td> 
   <td>值为6</td> 
  </tr> 
  <tr> 
   <td>bytes</td> 
   <td>u8</td> 
   <td>按照高位在前存储double值</td> 
  </tr> 
  <tr> 
   <td colspan="1">CONSTANT_Class_info</td> 
   <td>类或接口的符号引用</td> 
   <td>tag</td> 
   <td>u1</td> 
   <td>值为7</td> 
  </tr> 
  <tr> 
   <td>index</td> 
   <td>u2</td> 
   <td>指向全限定名常量项的索引</td> 
  </tr> 
  <tr> 
   <td colspan="1">CONSTANT_String_info</td> 
   <td>字符串类型字面量</td> 
   <td>tag</td> 
   <td>u1</td> 
   <td>值为8</td> 
  </tr> 
  <tr> 
   <td>index</td> 
   <td>u2</td> 
   <td>指向字符串字面量的索引</td> 
  </tr> 
  <tr> 
   <td colspan="1">CONSTANT_Fieldref_info</td> 
   <td>字段的符号引用</td> 
   <td>tag</td> 
   <td>u1</td> 
   <td>值为9</td> 
  </tr> 
  <tr> 
   <td>index</td> 
   <td>u2</td> 
   <td>指向声明字段的类或者接口描述符CONSTANT_Class_info的索引项</td> 
  </tr> 
  <tr> 
   <td>index</td> 
   <td>u2</td> 
   <td>指向字段描述符CONSTANT_NameAndType的索引项</td> 
  </tr> 
  <tr> 
   <td colspan="1">CONSTANT_Methodref_info</td> 
   <td>类中方法的符号引用</td> 
   <td>tag</td> 
   <td>u1</td> 
   <td>值为10</td> 
  </tr> 
  <tr> 
   <td>index</td> 
   <td>u2</td> 
   <td>指向声明方法的类描述符CONSTANT_Class_info的索引项</td> 
  </tr> 
  <tr> 
   <td>index</td> 
   <td>u2</td> 
   <td>指向名称及类型描述符CONSTANT_NameAndType的索引项</td> 
  </tr> 
  <tr> 
   <td colspan="1">CONSTANT_InterfaceMethodref_info</td> 
   <td>接口方法的符号引用</td> 
   <td>tag</td> 
   <td>u1</td> 
   <td>值为11</td> 
  </tr> 
  <tr> 
   <td>index</td> 
   <td>u2</td> 
   <td>指向声明方法的接口描述符CONSTANT_Class_info的索引项</td> 
  </tr> 
  <tr> 
   <td>index</td> 
   <td>u2</td> 
   <td>指向名称及类型描述符CONSTANT_NameAndType的索引项</td> 
  </tr> 
  <tr> 
   <td colspan="1">CONSTANT_NameAndType_info</td> 
   <td>字段或方法的部分符号引用</td> 
   <td>tag</td> 
   <td>u1</td> 
   <td>值为12</td> 
  </tr> 
  <tr> 
   <td>index</td> 
   <td>u2</td> 
   <td>指向该字段或方法名称常量项的索引</td> 
  </tr> 
  <tr> 
   <td>index</td> 
   <td> <p>u2</p> </td> 
   <td>指向该字段或方法描述符常量项的索引</td> 
  </tr> 
  <tr> 
   <td colspan="1">CONSTANT_MethodHandle_info</td> 
   <td>表示方法句柄</td> 
   <td>tag</td> 
   <td>u1</td> 
   <td>值为15</td> 
  </tr> 
  <tr> 
   <td>reference_kind</td> 
   <td>u1</td> 
   <td> <p>值必须在1至9之间(包括1和9),他决定了方法句柄的类型</p> <p>方法句柄类型的值标识方法句柄的字节码行为</p> </td> 
  </tr> 
  <tr> 
   <td>reference_index</td> 
   <td>u2</td> 
   <td>值必须是对常量池的有效索引</td> 
  </tr> 
  <tr> 
   <td colspan="1">CONSTANT_MethodType_info</td> 
   <td>表示方法类型</td> 
   <td>tag</td> 
   <td>u1</td> 
   <td>值为16</td> 
  </tr> 
  <tr> 
   <td>descriptor_index</td> 
   <td>u2</td> 
   <td>值必须是对常量池的有效索引,常量池在该索引处的项必须是CONSTANT_Utf8_info结构,表示方法的描述符</td> 
  </tr> 
  <tr> 
   <td colspan="1">CONSTANT_Dynamic_info</td> 
   <td>表示一个动态计算常量</td> 
   <td>tag</td> 
   <td>u1</td> 
   <td>值为17</td> 
  </tr> 
  <tr> 
   <td>bootstrap_method_attr_index</td> 
   <td>u2</td> 
   <td>值必须是对当前class文件中引导方法表的bootstrap_methods[]数组的有效索引</td> 
  </tr> 
  <tr> 
   <td>name_and_type_index</td> 
   <td>u2</td> 
   <td>值必须是对当前常量池的有效索引,常量池在该索引处的项必须是CONSTANT_NameAndType_info结构,表示方法名和方法描述符</td> 
  </tr> 
  <tr> 
   <td colspan="1">CONSTANT_InvokeDynamic_info</td> 
   <td>表示一个动态方法调用点</td> 
   <td>tag</td> 
   <td>u1</td> 
   <td>值为18</td> 
  </tr> 
  <tr> 
   <td>bootstrap_method_attr_index</td> 
   <td>u2</td> 
   <td>值必须是对当前Class文件中引导方法表的bootstrap_methods[]数组的有效索引</td> 
  </tr> 
  <tr> 
   <td>name_and_type_index</td> 
   <td>u2</td> 
   <td> <p>值必须是对当前常量池的有效索引,常量池在该索引处的项必须是CONSTANT_NameAndType_info结构,表示方法名和方法描述符</p> <p>&nbsp;</p> </td> 
  </tr> 
  <tr> 
   <td colspan="1">CONSTANT_Module_info</td> 
   <td>表示一个模块</td> 
   <td>tag</td> 
   <td>u1</td> 
   <td>值为19</td> 
  </tr> 
  <tr> 
   <td>name_index</td> 
   <td>u2</td> 
   <td>值必须是对常量池的有效索引,常量池在该处的项必须是CONSTANT_Utf8_info结构,表示模块名称</td> 
  </tr> 
  <tr> 
   <td colspan="1">CONSTANT_Package_info</td> 
   <td>表示一个模块中开放或者导出的包</td> 
   <td>tag</td> 
   <td>u1</td> 
   <td>值为20</td> 
  </tr> 
  <tr> 
   <td>name_index</td> 
   <td>u2</td> 
   <td>值必须是对常量池的有效索引,常量池在该处的项必须是CONSTANT_Utf8_info结构,表示包名称</td> 
  </tr> 
 </tbody> 
</table>

# 三.运行时常量池 #

jvm在执行某个类的时候，必须经过加载、连接、初始化，而连接又包括验证、准备、解析三个阶段。而当类加载到内存中后，jvm就会将 `class常量池` 中的内容存放到 `运行时常量池` 中，由此可知，`运行时常量池` 也是每个类都有一个。

`class常量池` 中存的是字面量和符号引用，也就是说他们存的并不是对象的实例，而是对象的符号引用值。而经过**解析（resolve）**之后，也就是把**符号引用替换为直接引用**，解析的过程会去查询 `字符串常量池` ，也就是我们上面所说的StringTable，以保证 `运行时常量池所` 引用的字符串与 `字符串常量池` 中所引用的是一致的。

# 四.字符串常量池 #

**字符串常量池是全局的，JVM中独此一份，因此也称为全局字符串常量池。**运行时常量池中的字符串字面量若是成员的，则在类加载初始化阶段就使用到了字符串常量池；若是本地的，则在使用到的时候才会使用字符串常量池。其实，“使用常量池”对应的字节码是一个ldc指令，在给String类型的引用赋值的时候会先执行这个指令，看常量池中是否存在这个字符串对象的引用，若有就直接返回这个引用，若没有，就在堆里创建这个字符串对象并在字符串常量池中记录下这个引用。String类的intern()方法还可以在运行期间把字符串放到字符串常量池中。

**String.intern()**

我们可以使用 String.intern 方法来操作字符串常量池。

该方法用来返回常量池中的某个字符串。简单来说该功能是利用 Hotspot 虚拟机里的一个 StringTable 来存储字符串，StringTable 底层使用 HashTable 来实现的。如果 StringTable 中已经存在该字符串（通过 String.equals 方法来判断是否存在），则直接返回常量池中该对象的引用。否则，在 StringTable 中加入该对象，然后返回对象的引用。

**代码示例: **

package com.basis;
    
    public class ConstantPool {
    
        public static void main(String []args) {
    
            // 1. 在堆中会有一个 abc 实例对象，全局 StringTable 中存放着 abc 的一个引用值。
            String str1 = "abc";
    
            // 2. 会生成两个实例，一个是 def 的实例对象，
            //    并且 StringTable 中存储一个 def 的引用值，
            //    还有一个是new出来的一个 def 的实例对象 。
            String str2 = new String("def");
    
    
            // 3. 当在解析str3的时候查找StringTable，
            //    里面有 abc 的全局驻留字符串引用，
            //    所以str3的引用地址与之前的那个已存在的相同 。
            String str3 = "abc";
    
    
            // 4. str4是在运行的时候调用 intern() 函数，
            //    返回StringTable中 def 的引用值，
            //    如果没有就将str2的引用值添加进去，
            //    在这里，StringTable中已经有了 def 的引用值了，
            //    所以返回上面在new str2的时候添加到StringTable中的 def 引用值.
            String str4 = str2.intern();
    
            // str5在解析的时候就也是指向存在于StringTable中的 def 的引用值。
            String str5 = "def";
    
            String str6 = str1.intern();
    
    
    
            // str1 str3 在字符串常量池中是同一个引用,所以是true
            System.out.println(str1 == str3); //true
    
            System.out.println(str4);
    
            // str2 对象 的引用和 str4的引用不是同一个引用地址.
            // str2 会产生两个地址, 这里的str2 指向的是new的对象的地址, 和str4里面指向的def地址不同.
            // str4 引用的是str2在new 对象之前已经向常量池中放入的 def 地址 的引用.
            System.out.println(str2 == str4); //false
    
            // str4 str5 在字符串常量池中是同一个引用,所以是true
            System.out.println(str4 == str5); //true
    
    
            System.out.println("-------------");
            //刷新str4的引用为def的引用
            str4 = "def";
    
            // str2 对象 的引用和 str4的引用不是同一个引用地址.
            // str2 会产生两个地址, 这里的str2 指向的是new的对象的地址, 和str4里面指向的def地址不同.
            // str4 引用的是str2在new 对象之前已经向常量池中放入的 def 地址 的引用.
            System.out.println(str2 == str4); //false
    
            // str2 的引用和 str4的引用不是同一个引用地址.
            // str4 引用的是str5的引用.
            System.out.println(str4 == str5); //true
    
            // str1 str5 在字符串常量池中是同一个引用,所以是true
            System.out.println(str1 == str6);
    
            //str6会直接引用 字符串常量池中的引用,这个引用和str5的引用是一样的
            str6 = "def";
            // str6 str5 在字符串常量池中是同一个引用,所以是true
            System.out.println(str5 == str6);
        }
    }

> VM中除了字符串常量池，8种基本数据类型中除了两种浮点类型外，其它的6种基本数据类型的包装类都使用了缓冲池，但是Byte、Short、Integer、Long、Character这几个包装类只有对应值在\[-128,127\]时才会使用缓冲池，超出此范围仍会去创建新的对象。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70]: /images/20221123/91d551709eec44eebf2bef551089c12e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70 1]: /images/20221123/09dde7c84c59400e894cd4fbcd22f0c3.png
[https_www.processon.com_view_5f45d1d9e0b34d638e07816d]: https://www.processon.com/view/5f45d1d9e0b34d638e07816d
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70 2]: /images/20221123/8226424c0aa04b7dab87d4f579597b9b.png