深入剖析常量池
前言
首先，常量池这玩意我们并不陌生，反复出现constant pool，如class反编译后文件中就有Constant pool，但我们知道最开始出现是在类文件结构中
A class file consists of a single ClassFile structure:
ClassFile {
u4 magic; //魔数
u2 minor_version; //次版本
u2 major_version; //主版本
u2 constant_pool_count; //常量池数量
cp_info constant_pool[constant_pool_count-1]; //常量池
u2 access_flags;
u2 this_class;
u2 super_class;
u2 interfaces_count;
u2 interfaces[interfaces_count];
u2 fields_count;
field_info fields[fields_count];
u2 methods_count;
method_info methods[methods_count];
u2 attributes_count;
attribute_info attributes[attributes_count];
}
案例代码：
public class Math {
public static final int initData = 666;
public static User user = new User();
public Math() {
}
public int compute() {
int a = 1;
int b = 2;
int c = (a + b) * 10;
this.show();
return c;
}
public void show() {
System.out.println("hahaha");
}
public static void main(String[] args) {
Math math = new Math();
math.compute();
}
}
前期编译后对应的class文件：
通过类文件结构格式，以及十六进制的class文件，我们知道magic：CAFEBABE，minor_version：0000，major_version：0034，constant_pool_count：003A等，003A转化为十进制是58，常量池的数量是58，这种通过类文件格式去找接下来的常量池对我们是非常不友好的，通过javap -v -p Math.class反编译后的内容：
Classfile /E:/workdir/projects/jvm/target/classes/com/jiang/jvm/Math.class
Last modified 2023-10-16; size 1001 bytes
MD5 checksum 833fc1a28b8c10c9be87c5b01fc3af8a
Compiled from "Math.java"
public class com.jiang.jvm.Math
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #12.#40 // java/lang/Object."<init>":()V
#2 = Methodref #6.#41 // com/jiang/jvm/Math.show:()V
#3 = Fieldref #42.#43 // java/lang/System.out:Ljava/io/PrintStream;
#4 = String #44 // hahaha
#5 = Methodref #45.#46 // java/io/PrintStream.println:(Ljava/lang/String;)V
#6 = Class #47 // com/jiang/jvm/Math
#7 = Methodref #6.#40 // com/jiang/jvm/Math."<init>":()V
#8 = Methodref #6.#48 // com/jiang/jvm/Math.compute:()I
#9 = Class #49 // com/jiang/jvm/User
#10 = Methodref #9.#40 // com/jiang/jvm/User."<init>":()V
#11 = Fieldref #6.#50 // com/jiang/jvm/Math.user:Lcom/jiang/jvm/User;
#12 = Class #51 // java/lang/Object
#13 = Utf8 initData
#14 = Utf8 I
#15 = Utf8 ConstantValue
#16 = Integer 666
#17 = Utf8 user
#18 = Utf8 Lcom/jiang/jvm/User;
#19 = Utf8 <init>
#20 = Utf8 ()V
#21 = Utf8 Code
#22 = Utf8 LineNumberTable
#23 = Utf8 LocalVariableTable
#24 = Utf8 this
#25 = Utf8 Lcom/jiang/jvm/Math;
#26 = Utf8 compute
#27 = Utf8 ()I
#28 = Utf8 a
#29 = Utf8 b
#30 = Utf8 c
#31 = Utf8 show
#32 = Utf8 main
#33 = Utf8 ([Ljava/lang/String;)V
#34 = Utf8 args
#35 = Utf8 [Ljava/lang/String;
#36 = Utf8 math
#37 = Utf8 <clinit>
#38 = Utf8 SourceFile
#39 = Utf8 Math.java
#40 = NameAndType #19:#20 // "<init>":()V
#41 = NameAndType #31:#20 // show:()V
#42 = Class #52 // java/lang/System
#43 = NameAndType #53:#54 // out:Ljava/io/PrintStream;
#44 = Utf8 hahaha
#45 = Class #55 // java/io/PrintStream
#46 = NameAndType #56:#57 // println:(Ljava/lang/String;)V
#47 = Utf8 com/jiang/jvm/Math
#48 = NameAndType #26:#27 // compute:()I
#49 = Utf8 com/jiang/jvm/User
#50 = NameAndType #17:#18 // user:Lcom/jiang/jvm/User;
#51 = Utf8 java/lang/Object
#52 = Utf8 java/lang/System
#53 = Utf8 out
#54 = Utf8 Ljava/io/PrintStream;
#55 = Utf8 java/io/PrintStream
#56 = Utf8 println
#57 = Utf8 (Ljava/lang/String;)V
{
public static final int initData;
descriptor: I
flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL
ConstantValue: int 666
public static com.jiang.jvm.User user;
descriptor: Lcom/jiang/jvm/User;
flags: ACC_PUBLIC, ACC_STATIC
public com.jiang.jvm.Math();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 9: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lcom/jiang/jvm/Math;
public int compute();
descriptor: ()I
flags: ACC_PUBLIC
Code:
stack=2, locals=4, args_size=1
0: iconst_1
1: istore_1
2: iconst_2
3: istore_2
4: iload_1
5: iload_2
6: iadd
7: bipush 10
9: imul
10: istore_3
11: aload_0
12: invokevirtual #2 // Method show:()V
15: iload_3
16: ireturn
LineNumberTable:
line 14: 0
line 15: 2
line 16: 4
line 17: 11
line 18: 15
LocalVariableTable:
Start Length Slot Name Signature
0 17 0 this Lcom/jiang/jvm/Math;
2 15 1 a I
4 13 2 b I
11 6 3 c I
public void show();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=1, args_size=1
0: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #4 // String hahaha
5: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 21: 0
line 22: 8
LocalVariableTable:
Start Length Slot Name Signature
0 9 0 this Lcom/jiang/jvm/Math;
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=2, args_size=1
0: new #6 // class com/jiang/jvm/Math
3: dup
4: invokespecial #7 // Method "<init>":()V
7: astore_1
8: aload_1
9: invokevirtual #8 // Method compute:()I
12: pop
13: return
LineNumberTable:
line 24: 0
line 25: 8
line 26: 13
LocalVariableTable:
Start Length Slot Name Signature
0 14 0 args [Ljava/lang/String;
8 6 1 math Lcom/jiang/jvm/Math;
static {};
descriptor: ()V
flags: ACC_STATIC
Code:
stack=2, locals=0, args_size=0
0: new #9 // class com/jiang/jvm/User
3: dup
4: invokespecial #10 // Method com/jiang/jvm/User."<init>":()V
7: putstatic #11 // Field user:Lcom/jiang/jvm/User;
10: return
LineNumberTable:
line 11: 0
}
SourceFile: "Math.java"
这是学习接下来知识点的前置条件，了解会更容易理解接下来的内容！
静态常量池
静态常量池是相对于运行时常量池来说的，属于描述class文件结构的一部分，在前言部门，从类文件结构到我们所容易看懂的反编译后的文件，也证明了这一观点
由字面量和符号引用组成，在类被加载后会将静态常量池加载到内存中也就是运行时常量池。
字面量：字面量就是指由字母、数字等构成的字符串或者数值常量（Final修饰的内容）
字面量只可以右值出现，所谓右值是指等号右边的值，如：int a=1 这里的a为左值，1为右值。在这个例子中1就是字面量。
int a = 1;
int b = 2;
符号引用：符号引用是编译原理中的概念，是相对于直接引用来说的。主要包括了以下三类常量：
- 类和接口的全限定名
- 字段的名称和描述符
- 方法的名称和描述符
上面的a，b就是字段名称，就是一种符号引用，还有Math类常量池里的 Lcom/jvm/Math 是类的全限定名，main、compute、show是方法名称，()是一种UTF8格式的描述符，这些都是符号引用。
这些常量池现在是静态信息，只有到运行时被加载到内存后，这些符号才有对应的内存地址信息，这些常量池一旦被装入内存就变成运行时常量池，对应的符号引用在程序加载或运行时会被转变为被加载到内存区域的代码的直接引用，也就是我们说的动态链接了。例如，compute()这个符号引用在运行时就会被转变为compute()方法具体代码在内存中的地址，主要通过对象头里的类型指针去转换直接引用。
字符串常量池
1、字符串的分配，和其它对象分配一样，耗费高昂的时间和空间代价，作为最基础的数据类型，大量频繁的创建字符串，极大程度地影响了程序的性能
2、JVM为了提高性能和减少内存开销，在实例化字符串常量的时候进行了一些优化
①为字符串开辟一个字符串常量池，类似于缓存区
②创建字符串常量时，首先查询字符串常量池是否存在该字符串
③存在该字符串，返回引用实例，不存在，实例化该字符串并放入池中
JDK1.6及之前版本，字符串常量池位于永久代（相当于现在的方法区）
JDK1.7：有永久代，但已经逐步“去永久代”，字符串常量池从永久代里的运行时常量池分离到堆里
JDK1.8及之后： 无永久代，运行时常量池在元空间，字符串常量池里依然在堆里
常量池在内存中的布局：
三种字符串操作【JDK1.7及以上】：
直接赋值操作：
String s = "test"; //s指向常量池中的引用，最多创建1个对象
//这种方式创建的字符串对象，只会在常量池中，因为有"test"这个字面量，创建对象的时候，
//JVM会先去常量池中通过equals(key)方法，判断是否有相同的对象，
//如果没有，则会在常量池创建一个新对象，再返回引用
new String();
String s1 = new String("test"); //s1指向内存中的对象引用，最多创建2个对象
//这种方式会保证字符串常量池和堆中都有这个对象，没有就创建，最后返回堆内存中对象引用。
//因为有"test"这个字面量，所以会先去字符串常量池中检查有没有"test"字符串，如果没有则创建，再去
//内存中创建一个"test"对象，如果有去内存中创建一个"test"对象，则最后，将内存中引用返回。
intern方法
String s1 = new String("test");
String s2 = s1.intern();
System.out.println( s1==s2 ); //false
//String中的intern()方法是一个native的方法，当调用intern方法时，
//如果池已经包含一个等于此String对象的字符串(用equals(object)方法确定)，则返回池中的字符串,
//否则，将intern返回的引用指向当前字符串s1(JDK1.6版本需要将s1复制到字符串常量池中)
看一道常见的面试题，深入理解字符串常量池设计原理，同时大家可以仔细思考在JDK1.6、JDK1.7下结果是怎样的，最多会创建几个对象！
String s1 = new String("he") + new String("llo");
String s2 = s1.intern();
System.out.println( s1==s2 );
//JDK1.6输出的是false，最多创建6个对象
//JDK1.7及以上版本输出的是true,最多创建5个对象
JDK1.6版本：
JDK1.7版本及以上：
String常量池问题的几个例子：
String s0 = "hello";
String s1 = "hello";
String s2 = "he" + "llo";
System.out.println( s0==s1); //true
System.out.println( s0==s2); //true
//s0和s1中的"hello"都是字符串常量，在编译期间就被确定了，所以s0=s1为true，
//而"he"和"llo"也都是字符串常量，当一个字符串由多个字符串常量连接而成时，
//它自己肯定也是字符串常量，所以s2同样在编译期被优化为一个字符串常量"hello"，所以s0=s1=2，为true
String a = "ab";
final String bb = "b";
String b = "a" + bb;
System.out.println(a == b); // true
//对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中货嵌入到它的字节码流中，所以为true
String a = "ab";
final String bb = getBB();
String b = "a" + bb;
System.out.println(a == b); // false
private static String getBB()
{
return "b";
}
//JVM对于字符串引用bb，它的值在编译期无法确定，只有在程序运行期调用方法后，将方法的返回值和"a"来动态
//连接并分配地址为b，故上面 程序的结果为false。
String s = "a" + "b" + "c"; //就等价于String s = "abc";
String a = "a";
String b = "b";
String c = "c";
String s1 = a + b + c; //等同于StringBuilder temp = new StringBuilder();temp.append(a).append(b).append(c);String s = temp.toString();
System.out.println(s == s1); //false
StringBuilder中append(String str)后，最后toStringf()方法里返回new String(value, 0, count);，所以s==s1，结果为false。
//字符串常量池："计算机"和"技术" 堆内存：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时才可使用对象池，也即对象不负责创建和管理大于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
}
}
扫一扫
1819
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
