题目

攻克你的技术盲点之JVM常量池

知识点

什么是常量

用final修饰的成员变量表示常量，值一旦给定就无法改变。

• final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。

JVM中的方法区

JVM的方法区里存放着类的版本，字段，方法，接口和常量池。常量池里存储着字面量和符号引用。

Java中的常量池

实际上分为两种形态：静态常量池和运行时常量池。

静态常量池

静态常量池，即class文件中的常量池，class文件中的常量池不仅仅包含字符串(数字)字面量，还包含类、方法的信息，占用class文件绝大部分空间。

class常量池

• 当java文件被编译成class文件之后，会在class文件中生成我们所说的class常量池。
  
• class文件中除了包含类的版本、字段、方法、接口等描述信息外，还有一项信息就是常量池(constant pool table)，用于存放编译器生成的【各种字面量】(文本字符串、被声明为final的常量、基本数据类型的值)和【符号引用】(类和接口的全限定名、字段的名称和描述符、方法的名称和描述符)，这部分内容将在类加载后进入方法区的运行时常量池中存放。
  

常量池中存放的符号信息，在JVM执行指令时需要依赖使用。常量池中的所有项都具有如下通用格式：

cp_info {
    u1 tag;     //表示cp_info的单字节标记位
    u1 info[];  //两个或更多的字节表示这个常量的信息，信息格式由tag的值确定
}
复制代码

支持的类型信息如下：

以CONSTANT_Class为例，它用于表示类或者接口，格式如下：

CONSTANT_Class_info {
 u1 tag;
 u2 name_index;
复制代码

• CONSTANT_Class_info类型是由一个tag和一个name_index组成。

• tag：这个值为CONSTANT_Class (7)，代表着属于一个类的引用（CONSTANT_Fieldref代表字段引用）
  
• name_index中的index表示它是一个索引，引用的是CONSTANT_UTF8_info。

• CONSTANT_Utf8_info用于表示字符常量的值，结构如下所示：
  

CONSTANT_Utf8_info {
 u1 tag;
 u2 length;
 u1 bytes[length];
}
复制代码

• tag表示为：CONSTANT_Utf8（1），代表着属于一个字符串值得引用；
  
• length：指明了bytes[]数组的长度；bytes[]数组引用了上一个length作为其长度。字符常量采用改进过的UTF-8编码表示。

多余说一句：对于静态常量池我们需要知道它存在于编译器，如果说与运行时有关的话，可以说运行时中的常量是JVM加载class文件之后进行分配的。

运行时常量池

运行时常量池，运行时常量池是方法区的一部分，则是jvm虚拟机在完成类装载操作后，将class文件中的常量池载入到内存中，并保存在方法区中，我们常说的常量池，就是指方法区中的运行时常量池。

• 运行时常量池相对于Class文件常量池的另外一个重要特征是具备动态性，Java语言并不要求常量一定只有编译期才能产生，也就是并非预置入Class文件中常量池的内容才能进入方法区运行时常量池，运行期间也可能将新的常量放入池中，这种特性被开发人员利用比较多的就是String类的intern()方法。
  
• 当类加载到内存中后，JVM就会将class常量池中的内容存放到运行时常量池中，由此可知，运行时常量池也是每个类都有一个。

• 运行时常量池用来动态获取类信息，包括：class文件元信息描述、编译后的代码数据、引用类型数据、类文件常量池的其他数据等。
  
• class常量池中存的是字面量和符号引用，也就是说他们存的并不是对象的实例，而是对象的符号引用值，加载阶段：将每个class常量池中的符号引用值转存到运行时常量池中。
  
• 之后经过解析（resolve）之后，也就是把符号引用替换为直接引用，解析的过程会去查询字符串常量池，也就是我们上面所说的string pool，以保证运行时常量池所引用的字符串与字符串常量池中所引用的是一致的。

字符串常量池（string pool）

字符串常量池里的内容是在类加载完成，经过验证，准备阶段之后在堆中生成字符串对象实例，然后将该字符串对象实例的引用值存到string pool中（记住：在jdk1.8后string pool中存的是引用值而不是具体的实例对象，具体的实例对象是在堆中开辟的一块空间存放的）。string pool在每个HotSpot VM的实例只有一份，被所有的类共享。

• 字符串池里的内容是在类加载完成，经过验证、准备阶段之后存放在字符串常量池中。关于字符串常量池的具体实现我们这里先不展开，后面用专门的文章来进行讲解。
  
• 字符串常量池的处理机制我们前面文章已经讲到，只会存储一份，被所有的类共享。基本流程是：创建字符串之前检查常量池中是否存在，如果存在则获取其引用，如果不存在则创建并存入，返回新对象引用。

不同版本的字符串常量池

字符串常量池随着JDK版本的演化所在的位置也在不断的变化，下面我们会专门用图讲解一下。

在JDK1.7字符串常量池和静态变量被从方法区拿到了堆中，运行时常量池剩下的还在方法区, 也就是hotspot中的永久代。

在JDK8 hotspot移除了永久代用元空间(Metaspace)取而代之, 这时候字符串常量池还在堆，运行时常量池还在方法区，只不过方法区的实现从永久代变成了元空间(Metaspace)

需要注意的点：

常量池的好处

常量池是为了避免频繁的创建和销毁对象而影响系统性能，其实现了对象的共享。

例如字符串常量池，在编译阶段就把所有的字符串文字放到一个常量池中。

1. 节省内存空间：常量池中所有相同的字符串常量被合并，只占用一个空间。
   
2. 节省运行时间：比较字符串时，==比equals()快。对于两个引用变量，只用==判断引用是否相等，也就可以判断实际值是否相等。

拓展延伸

String s1=new String("abc"); 
复制代码

首先你要理解常量池,  这是一个特殊的共享区域，literate（符号引用）, Class这些可以在内存中共享的不经常改变的东西，都可以放在这里。

• 上面的代码会有两个String被创建，一个是你的Class被ClassLoader加载时，你的"abc"被作为常量读入，在字符串常量池里创建了一个共享的"abc"
  
• 然后，当调用到new  String("abc")的时候，会在heap里创建这个new  String("abc");
  

考虑类加载阶段和实际执行时。

• 类加载对一个类只会进行一次。"abc"在类加载时就已经创建并驻留了（如果该类被加载之前已经有"abc"字符串被驻留过则不需要重复创建，直接使用驻留的"abc"实例）。驻留的字符串是放在全局共享的字符串常量池中的。
  
• "abc"字面量对应的String实例已经固定了，不会再被重复创建。所以这段代码将常量池中的对象复制一份放到heap中，并且把heap中的这个对象的引用交给s1持有。
  

public class Test{
    public static String a = "a";
    public static void main(){
        String b = "b";
    }
}
复制代码

使用Java自带的反编译工具反编译一下，编译后输入javap -verbose Test.cass

可以发现两个静态String变量都放入了常量池中

public class Test2{
    public static String str = "laji" + "MySQL";
    public static void main(){
    }
}
复制代码

在编译前先分析一波，按理说，既然是静态String常量，那么理应出现在常量池（Constant Pool）中

不会出现单独的两个元素的字符串常量，只会存在连接以后的数据。

public class Test2_2{
    public static void main(String[] args){
        String string1 = "laji";  
        String string2 = "MySQL";  
        String string3 = string1+string2;  
        String string4 = string1+"C";   
    }
}

• 对于直接做+运算的两个字符串（字面量）常量，并不会放入String常量池中，而是直接把运算后的结果放入常量池中。
  
• 对于先声明的字符串字面量常量，会放入常量池，但是若使用字面量的引用进行运算就不会把运算后的结果放入常量池中了

总结一下就是JVM会对String常量的运算进行优化，未声明的，只放结果；已经声明的，只放声明。

public class Test3{
    public static void main(String[] args){
        String str = "laji";
        String str2 = new String("MySQL");
        String str3 = new String("laji");
        System.out.println(str==str3);// 运行后结果为false
    }
}

首先是new一个对象时，明明是在堆中实例化一个对象，怎么会出现常量池中？

这里的"MySQL"并不是字符串常量出现在常量池中的，而是以字面量出现的，实例化操作（new的过程）是在运行时才执行的，编译时并没有在堆中生成相应的对象。

最后输出的结果之所以是false，就是因为str指向的”laji”是存放在常量池中的，而str3指向的”laji”是存放在堆中的，==比较的是引用（地址），当然是false

public class Test4{
    public static void main(String[] args){
        String str = "laji";
        String str2 = new String("laji");
        String str3 = null;
        System.out.println(str==str2);// 运行后结果为false
        str3 = str2.intern();
        System.out.println(str==str3);// 运行后结果为true
    }
}
复制代码

显然，str3在初始化的时候是从字符串常量池中获取到的值。

JDK1.7中JVM把String常量区从方法区中移除了；JDK1.8中JVM把String常量池移入了堆中，同时取消了“永久代”，改用元空间代替（Metaspace）

import java.util.ArrayList;
public class TestString {
    public static void main(String[] args) {
            String str = "abc";  
            char[] array = {'a', 'b', 'c'};  
            String str2 = new String(array);  
            //使用intern()将str2字符串内容放入常量池  
            str2 = str2.intern();  
            //这个比较用来说明字符串字面常量和我们
            //使用intern处理后的字符串是在同一个地方  
            System.out.println(str == str2);  
    }
}
复制代码

总结一下

• 静态变量（静态常量池）处于编译器，存在于class文件内，可通过javap - verbose命令查看字符串合并时查看的是静态常量池里面的内容；

• 字符串常量池曾经属于运行时常量池的一部分，位于方法区，但随着JVM版本的演变，二者已经分开。在JDK8以后字符串常量池位于堆中，而运行时常量池位于方法区。