JVM深入解析三之常量池

Class常量池

Class文件是以十六进制保存的，当然我们一般可以通过javap -v XXX.class命令生成更可读的JVM字节码指令文件。

Class常量池可以理解为是Class文件中的资源仓库。 Class文件中除了包含类的版本、字段、方法、接口等描述信息外， 还有一项信息就是常量池(constant pool table)，用于存放编译期生成的各种字面量(Literal)和符号引用(Symbolic References)。

字面量

字面量就是指由字母、数字等构成的字符串或者数值常量，字面量只可以右值出现，所谓右值是指等号右边的值。

符号引用

符号引用是编译原理中的概念，是相对于直接引用来说的。主要包括了以下三类常量：

• 类和接口的全限定名
• 字段的名称和描述符
• 方法的名称和描述符

运行时常量池

在类编译阶段是静态信息，只有到运行时被加载到内存后，这些符号才有对应的内存地址信息，这些常量池一旦被装入内存就变成运行时常量池。对应的符号引用在程序加载或运行时会被转变为被加载到内存区域的代码的直接引用，也就是我们说的动态链接了，还有一点符号引用在运行时就会被转变为方法具体代码在内存中的地址，主要通过对象头里的类型指针去转换直接引用。

字符串常量池

字符串常量池的设计思想

1. 字符串的分配，和其他的对象分配一样，耗费高昂的时间与空间代价，作为最基础的数据类型，大量频繁的创建字符串，极大程度地影响程序的性能。

2. JVM为了提高性能和减少内存开销，在实例化字符串常量的时候进行了一些优化

• 为字符串开辟一个字符串常量池，类似于缓存区
• 创建字符串常量时，首先查询字符串常量池是否存在该字符串
• 存在该字符串，返回引用实例，不存在，实例化该字符串并放入池中

字符串操作(Jdk1.7 及以上版本)

直接赋值字符串

String s = "shen"; // s指向常量池中的引用

这种方式创建的字符串对象，只会在字符串常量池中,创建对象s的时候，JVM会先去字符串常量池中通过 equals(key) 方法，判断是否有相同的对象 如果有，则直接返回该对象在字符串常量池中的引用； 如果没有，则会在字符串常量池中创建一个新对象，再返回引用。

New对象

String s1 = new String("shen"); // s1指向内存中的对象引用

这种方式会保证字符串常量池和堆中都有这个对象，没有就创建，最后返回堆内存中的对象引用。注意：如果常量池中存在"shen"，那么直接在内存中创建字符串对象，返回内存中引用；如果没有，先去字符串常量池中创建字符串常量，然后再在内存中创建字符串对象，返回内存中引用；也就是说一个会创建一个对象，一个会创建两个。

intern方法

String s1 = new String("shen");
String s2 = s1.intern();

String中的intern方法是一个 native 的方法， 当调用 intern方法时， 如果字符串常量池已经包含一个等于此String对象的字符串 （用equals(oject)方法确定），则返回池中的字符串。否则，将intern返回的引用指向当前字符串 s1(jdk1.6版本需要将 s1 复制到字符串常量池里)。

字符串常量池位置

Jdk1.6及之前： 有永久代, 运行时常量池在永久代，运行时常量池包含字符串常量池

Jdk1.7：有永久代，但已经逐步“去永久代”，字符串常量池从永久代里的运行时常量池分离到堆里

Jdk1.8及之后： 无永久代，运行时常量池在元空间，字符串常量池里依然在堆里

字符串常量池设计原理

字符串常量池底层是hotspot的C++实现的，底层类似一个 HashTable， 保存的本质上是字符串对象的引用。

举例：

String s1 = new String("he") + new String("llo");
String s2 = s1.intern();
System.out.println(s1 == s2);

在 JDK 1.6 下输出是 false，创建了 6 个对象；在 JDK 1.7 及以上的版本输出是 true，创建了 5 个对象

为什么输出会有这些变化呢？主要还是字符串池从永久代中脱离、移入堆区的原因， intern() 方法也相应发生了变化：

1、在 JDK 1.6 中，调用 intern() 首先会在字符串池中寻找 equal() 相等的字符串，假如字符串存在就返回该字符串在字符串池中的引用；假如字符串不存在，虚拟机会重新在永久代上创建一个实例，将 StringTable 的一个表项指向这个新创建的实例。

2、在 JDK 1.7 (及以上版本)中，由于字符串池不在永久代了，intern() 做了一些修改，更方便地利用堆中的对象。字符串存在时和 JDK 1.6一样，但是字符串不存在时不再需要重新创建实例，可以直接指向堆上的实例。

String常量池案例

String s1="shen";
String s2 = "sh" + "en";

这两个是==的，因为在编译期间，程序会帮我们优化一次，“+”会优化掉。

String s2="sh" + new String("en");

这种因为有new存在，也不能在编译器完成，所以在运行期间会自动给“sh”加上new String。

String a = "ab";
String b = "b";
String c = "a" + b;

这种a!=b，在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的。但是底下这个是==的

String a = "ab";
final String b = "b";
String c = "a" + b;

对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。那么我们再来看一个

String a = "ab";
final String b = getB();
String c = "a" + b;

public static String getB(){
    return "b";
} 

JVM对于字符串引用b，它的值在编译期无法确定，只有在程序运行期调用方法后，将方法的返回值和"a"来动态连接并分配地址为b，故上面程序的结果为false。

通过以上例子我们再源码中可以找到其JVM指令码发现c的"+"操作会变成如下操作：

StringBuilder temp = new StringBuilder();
temp.append(a).append(b).append(c);
String s = temp.toString();

那么既然知道了源码，那么我们就再来分析一下

//堆内存中还有个StringBuilder的对象，但是会被gc回收，StringBuilder的toString方法会new String()，这个String才是真正返回的对 象引用
String str2 = new StringBuilder("计算机").append("技术").toString();
System.out.println(str2 == str2.intern());

String str1=new StringBuilder("ja").append("va").toString();
System.out.println(str1 == str1.intern());

String s1=new String("test");
System.out.println(s1==s1.intern());

String s2=new StringBuilder("abc").toString();
System.out.println(s2==s2.intern());

我们来分析下：

第一个是true还是false?

答案：true。为什么是true呢，不是说.intern()会先在字符串常量池中查找，存在直接返回的吗？这是因为没有出现"计算机技术"字面量，只有“计算机”、“技术”，所以不会在常量池里生成"计算机技术"，在池中没有，但是在heap中存在，则intern时，会直接返回该heap中的引用

第二个呢，一模一样，既然第一个是true，那么第二个毋庸置疑，肯定true呀，是吗？

答案：false。是不是意想不到呢？这是因为java是关键字，在JVM初始化的相关类里肯定早就放进字符串常量池了

第三个不用讲，为false之前说过，第四个呢？

答案：false。StringBuilder的toString方法会new String()，“abc”作为字面量是会放到常量池中的

八种基本类型的包装类和对象池

java中基本类型的包装类的大部分都实现了常量池技术(严格来说应该叫对象池，在堆上)，这些类是Byte,Short,Integer,Long,Character,Boolean,另外两种浮点数类型的包装类则没有实现。另外 Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127时才可使用对象池，也即对象不负 责创建和管理大于127的这些类的对象。因为一般这种比较小的数用到的概率相对较大。

//5种整形的包装类Byte,Short,Integer,Long,Character的对象，
//在值小于127时可以使用对象池
Integer i1 = 127; //这种调用底层实际是执行的Integer.valueOf(127)，里面用到了IntegerCache对象池
Integer i2 = 127;
System.out.println(i1 == i2); //输出true
//值大于127时，不会从对象池中取对象
Integer i3 = 128;
Integer i4 = 128;
System.out.println(i3 == i4); //输出false
//用new关键词新生成对象不会使用对象池
Integer i5 = new Integer(127);
Integer i6 = new Integer(127);
System.out.println(i5 == i6); //输出false
//Boolean类也实现了对象池技术
Boolean bool1 = true;
Boolean bool2 = true;
System.out.println(bool1 == bool2); //输出true
//浮点类型的包装类没有实现对象池技术
Double d1 = 1.0;
Double d2 = 1.0;
System.out.println(d1 == d2); //输出false