一、Class常量池与运行时常量池参考图灵学院
java文件在编译加载的时候其中有一个解析环节把符号引用转换成直接引用(静态链接)，在程序运行需要哪些资源的时候把符号引用转换成直接(动态链接)。
运行时常量池就是在java运行时需要从常量池中获取的常量池称为运行时常量池。JAVA属于一种懒加载方式。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oIv9uOuD-1640613649521)(Class常量池和运行时常量池.assets/clipboard.png)]
- 解析：将符号引用替换为直接引用(内存地址)，该阶段会把一些静态方法(符号引用，比如main()方法)替换为指向数据所存内存的指针或句柄等(直接引用)，这是所谓的静态链接过程(类加载期间完成)，动态链接是在程序运行期间完成的将符号引用替换为直接引用，下节课会讲到动态链接 【javap -v Hello.class 查看字节码文件。#32 符号引用】
查看字节码认识常量池(Constant Pool)
javap -v Math.class > d://MathClass.txt
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Le5r9rNd-1640613649525)(Class常量池和运行时常量池.assets/clipboard-1640606771587.png)]
常量池中主要存放两大类常量：字面量和符号引用。
1.1 字面量字面量就是指由字母、数字等构成的字符串或者数值常量
字面量只可以右值出现，所谓右值是指等号右边的值，如：int a=1 这里的a为左值，1为右值。在这个例子中1就是字面量。
String name = "tom"; int num = 125;1.2 符号引用
package com.mayikt.jvm;
import com.mayikt.jvm.model.entity.User;
public class Math {
public static final int initData = 666;
//public static User user 放到方法区(元空间)
//new User() 放到堆空间
//他们之间使用指针引用进行关联
public static User user = new User();
public int compute() { //一个方法对应一块栈帧内存区域
int a = 1;
int b = 2;
int c = (a + b) * 10;
return c;
}
public static void main(String[] args) {
Math math = new Math();
math.compute();
}
}
符号引用是编译原理中的概念，是相对于直接引用来说的。主要包括了以下三类常量：
- 类和接口的全限定名
- 字段的名称和描述符
- 方法的名称和描述符
上面的name，num就是字段名称，就是一种符号引用，还有Math类常量池里的Lcom/mayikt/jvm/Math是类的全限定名，main和compute是方法名称，()是一种UTF8格式的描述符，这些都是符号引用。
这些常量池现在是静态信息，只有到运行时被加载到内存后，这些符号才有对应的内存地址信息，这些常量池一旦被装入内存就变成运行时常量池，对应的符号引用在程序加载或运行时会被转变为被加载到内存区域的代码的直接引用，也就是我们说的动态链接了。例如，compute()这个符号引用在运行时就会被转变为compute()方法具体代码在内存中的地址，主要通过对象头里的类型指针kalss point去转换直接引用。（指向元空间class内存地址）
二、字符串常量池JDK8字符串常量池放到堆空间,其引用指向元空间(方法区)的常量池。常量池设计就是一种缓存池，为了提高程序性能。
- 为字符串开辟一个字符串常量池，类似于缓存区
- 创建字符串常量时，首先查询字符串常量池是否存在该字符串
- 存在该字符串，返回引用实例，不存在，实例化该字符串并放入池中
version >=JDK7
2.1.1 直接赋值字符串String name = "tom";
创建的字符串对象，只会在常量池中。tom属于字面量，创建name对象的时候，JVM会先去常量池中通过equals(key)方法，判断是否有相同的对象
- 如果有，则直接返回该对象在常量池中的引用；
- 如果没有，则会在常量池中创建一个新对象，再返回引用
String name = new String("tom");//name指向内存中的对象引用
//运行时创建的新对象”tom”的引用
从两方面拆分来看:
- String name ---->name指向内存中的对象引用
- new String(“tom”)—->new 在堆内存中创建对象
它保证字符串常量池和堆中都有这个对象，没有就创建，最后返回堆内存中的对象引用。
步骤:
- tom字面量，先价差字符串常量池中是否存在字面量tom
- 不存在,先在字符串常量池中创建一个字符串对象
- 再去内存中(堆中)创建一个字符串对象"tom"
- 存在的话，就直接去堆内存中创建字符串对象tom
- 最后，将内存中的应用返回.
2.1.3 inter方法先看字符串常量池 ---->再看堆
public class StringDemo01 {
public static void main(String[] args) {
//先看字符串常量池中是否有tom字面量，如果没有先在字符串常量池中创建字符串对象“tom"
//再去内存堆中创建字符串对象
//把堆中的引用返回
String s1 = new String("tom");
String s2 = s1.intern();
//如果字符串常量池中有就返回，如果没有将intern返回的引用指向当前字符串 s1
//字符串不存在时不再需要重新创建实例，可以直接指向堆上的实例
//(jdk1.6版本需要将 s1 复制到字符串常量池里)。
String s3 = s1.intern();
System.out.println(s1 == s2); //false
System.out.println(s3==s2);//true
}
}
2.2 字符串常量池位置
-
Jdk1.6及之前： 有永久代, 运行时常量池在永久代，运行时常量池包含字符串常量池
-
Jdk1.7：有永久代，但已经逐步“去永久代”，字符串常量池从永久代里的运行时常量池分离到堆里
Jdk1.8及之后： 无永久代，运行时常量池在元空间，字符串常量池里依然在堆里
import java.util.ArrayList;
public class RuntimeConstantPoolOOM{
public static void main(String[] args) {
ArrayList list = new ArrayList();
for (int i = 0; i < 10000000; i++) {
String str = String.valueOf(i).intern();
list.add(str);
}
}
}
运行结果：
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at java.util.Arrays.copyOf(Arrays.java:3210)
at java.util.Arrays.copyOf(Arrays.java:3181)
at java.util.ArrayList.grow(ArrayList.java:265)
at java.util.ArrayList.ensureExplicitCapacity(ArrayList.java:239)
at java.util.ArrayList.ensureCapacityInternal(ArrayList.java:231)
at java.util.ArrayList.add(ArrayList.java:462)
at com.mayikt.jvm.stringpool.RuntimeConstantPoolOOM.main(RuntimeConstantPoolOOM.java:17)
2.3 字符串常量池设计原理
public class StringDemo02 {
public static void main(String[] args) {
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 个对象
// 当然我们这里没有考虑GC，但这些对象确实存在或存在过
字符串常量池底层是使用C++实现，其本质就是一个HashTable，保存字符串对象的引用
2.3.1 JDK1.6中设计[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ecEaM3CI-1640613649527)(Class常量池和运行时常量池.assets/clipboard-1640610570502.png)]
调用intern()方法首先在字符串常量池中通过equal(key)方法寻找相等的字符串。
- 如果字符串存在就返回该字符串在字符串常量池中的引用
- 如果没有在字符串常量池中，JVM会重新在永久代中创建一个实例，将String tale的一个表项指向这个新创建实例
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4jmPisJE-1640613649528)(Class常量池和运行时常量池.assets/clipboard-1640610812610.png)]
在 JDK 1.7 (及以上版本)中,intern() 做了一些修改：
- 如果字符串存在就返回该字符串在字符串常量池中的引用
- 字符串不存在时不再需要重新创建实例，可以直接指向堆上的实例
JDK 1.6字符串池溢出会抛出 OutOfMemoryError: PermGen space ，而在 JDK 1.7及以上版本抛出 OutOfMemoryError: Java heap space。
三、String常量池问题的几个例子 3.1 案例一
public class StringDemo03 {
public static void main(String[] args) {
String s0="abc";
String s1="abc";
String s2="ab" + "c"; //编译期会进行优化 ，
//放入常量池 “abc”是一个字面量(静态链接，编译的时候吧符号引用转换成直接引用---静态链接)
System.out.println( s0==s1 ); //true
System.out.println( s0==s2 ); //true
}
}
3.2 案例二分析：因为例子中的s0和s1中的”abc”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而”ab”和”c”也都是字符串常量，当一个字 符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被优化为一个字符串常量"abc"，所以s2也是常量池中” abc”的一个引用。所以我们得出s0==s1==s2；
public class StringDemo04 {
public static void main(String[] args) {
String s0 = "abcd";
String s1 = new String("ab"); //运行时创建的新对象”abcd”的引用
//new String 会在堆中创建对象，并且把引用进行返回,不会把创建的字符串放入常量池
String s2 = "ab" + new String("cd");
System.out.println(s0 == s1);// false
System.out.println(s0 == s2);// false
System.out.println(s1 == s2);// false
}
}
3.3 案例三分析：用new String()创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。s0还是常量池 中"abcd”的引用，s1因为无法在编译期确定，所以是运行时创建的新对象”abcd”的引用，s2因为有后半部分 new String(”cd”)所以也无法在编译期确定，所以也是一个新创建对象”abcd”的引用.
public class StringDemo05 {
public static void main(String[] args) {
test01();//字面量的"+"
test02();//字面量的"+"
test03();//字面量的"+"
}
public static void test03() {
String a = "a3.4";
String b = "a" + 3.4;
System.out.println(a == b); // true
}
public static void test02() {
String a = "atrue";
String b = "a" + "true";
System.out.println(a == b); // true
}
public static void test01() {
String a = "a1";
String b = "a" + 1;
System.out.println(a == b); // true
}
}
3.4 案例四分析：JVM对于字符串常量的"+"号连接，将在程序编译期，JVM就将常量字符串的"+"连接优化为连接后的值，拿"a" + 1来说，经编译器优化后在class中就已经是a1。在编译期其字符串常量的值就确定下来，故上面程序最终的结果都为true。
字面量"+",字符串
package com.mayikt.jvm.stringpool;
public class StringDemo06 {
public static void main(String[] args) {
String a = "ab";
String bb = "b";
String b = "a" + bb;
System.out.println(a == b); // false
String str01 = "abc";
String str02 = "abc";
System.out.println(str01 == str02);//true
String s1 = "a";
String s2 = "b";
String s3 = "c";
String s4 = s1+s2+s3;
System.out.println(s4==str01);//false
}
}
3.5 案例五分析：JVM对于字符串引用，由于在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的，即"a" + bb无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给``b。所以上面程序的结果也就为false。
public class StringDemo07 {
public static void main(String[] args) {
String a = "ab";
final String bb = "b";
String b = "a" + bb;
System.out.println(a == b); // true
}
}
3.6 案例六分析:bb字符串加了final修饰，对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。所以此时的"a" + bb和"a" + “b”效果是一样的。故上面程序的结果为true。
package com.mayikt.jvm.stringpool;
public class StringDemo08 {
public static void main(String[] args) {
String a = "ab";
//它的值在编译期无法确定，只有在程序运行期调用方法后，
// 将方法的返回值和"a"来动态连接并分配地址为b，
final String bb = getBB();
String b = "a" + bb;
System.out.println(a == b); // false
}
private static String getBB() {
return "b";
}
}
String s = "a" + "b" + "c"; //就等价于String s = "abc"; String a = "a"; String b = "b"; String c = "c"; String s1 = a + b + c;
s1 这个就不一样了，可以通过观察其JVM指令码发现s1的"+" *** 作会变成如下 *** 作
StringBuilder temp = new StringBuilder(); temp.append(a).append(b).append(c); String s = temp.toString();
创建StringBuilder ，通过append方法进行,toString()方法底层 new String(value, 0, count);
//字符串常量池："计算机"和"技术" 堆内存：str1引用的对象"计算机技术"
//堆内存中还有个StringBuilder的对象，但是会被gc回收，StringBuilder的toString方法会new String()，这个String才是真正返回的对象引用
String str2 = new StringBuilder("计算机").append("技术").toString(); //没有出现"计算机技术"字面量，所以不会在常量池里生成"计算机技术"对象
System.out.println(str2 == str2.intern()); //true
//"计算机技术" 在池中没有，但是在heap中存在，则intern时，会直接返回该heap中的引用
//字符串常量池："ja"和"va" 堆内存：str1引用的对象"java"
//堆内存中还有个StringBuilder的对象，但是会被gc回收，StringBuilder的toString方法会new String()，这个String才是真正返回的对象引用
String str1 = new StringBuilder("ja").append("va").toString(); //没有出现"java"字面量，所以不会在常量池里生成"java"对象
System.out.println(str1 == str1.intern()); //false
//java是关键字，在JVM初始化的相关类里肯定早就放进字符串常量池了
String s1=new String("test");
System.out.println(s1==s1.intern()); //false
//"test"作为字面量，放入了池中，而new时s1指向的是heap中新生成的string对象，s1.intern()指向的是"test"字面量之前在池中生成的字符串对象
String s2=new StringBuilder("abc").toString();
System.out.println(s2==s2.intern()); //false
四、八种基本类型的包装类和对象池
java中基本类型的包装类的大部分都实现了常量池技术(严格来说应该叫**对象池****，在堆上)，这些类是Byte,Short,Integer,Long,Character,Boolean,另外两种浮点数类型的包装类则没有实现。另外Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127(Integer:-128~127范围)**时才可使用对象池，也即对象不负责创建和管理大于127的这些类的对象。因为一般这种比较小的数用到的概率相对较大。
public class Test {
public static void main(String[] args) {
//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
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）