Java核心知识点-JVM结构之常量池

触摸java常量池

java常量池是一个经久不衰的话题，也是面试官的最爱，题目花样百出，小菜早就对常量池有所耳闻，这次好好总结一下。

理论

小菜先拙劣的表达一下jvm虚拟内存分布：

程序计数器是jvm执行程序的流水线，存放一些跳转指令，这个太高深，小菜不懂。

本地方法栈是jvm调用操作系统方法所使用的栈。

虚拟机栈是jvm执行java代码所使用的栈。

方法区存放了一些常量、静态变量、类信息等，可以理解成class文件在内存中的存放位置。

虚拟机堆是jvm执行java代码所使用的堆。

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

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

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

接下来我们引用一些网络上流行的常量池例子，然后借以讲解。

 1 String s1 = "Hello";//用new就放在堆中，没有new像这种直接赋值就放到常量池中
 2 String s2 = "Hello";
 3 String s3 = "Hel" + "lo";
 4 String s4 = "Hel" + new String("lo");
 5 String s5 = new String("Hello");
 6 String s6 = s5.intern();
 7 String s7 = "H";
 8 String s8 = "ello";
 9 String s9 = s7 + s8;//运行时合并两个字符串，在堆中创建字符串对象
10
11 System.out.println(s1 == s2);  // true
12 System.out.println(s1 == s3);  // true
13 System.out.println(s1 == s4);  // false
14 System.out.println(s1 == s9);  // false
15 System.out.println(s4 == s5);  // false
16 System.out.println(s1 == s6);  // true
17 System.out.println(s1 == s6);  // true


//附加：


Integer i=new Integer(123);
String s10=new String("123");



System.out.println(s5==s9);//false
System.out.println(s5.equals(s9));//true
System.out.println(s10.equals(i));//false
System.out.println(s10.equals(i.toString()));//true





首先说明一点，在java 中，如果是引用类型，使用==操作符，比较的是两个字符串的引用地址，并不是比较内容，比较内容和类型请用String.equals()。（三个比较量：变量的引用，内容，类型，详见：


http://www.cnblogs.com/zhxhdean/archive/2011/03/25/1995431.html


http://www.cnblogs.com/jackyrong/archive/2006/08/20/481994.html


）


s1 == s2这个非常好理解，s1、s2在赋值时，均使用的字符串字面量，说白话点，就是直接把字符串写死，在编译期间，这种字面量会直接放入class文件的常量池中，从而实现复用，载入运行时常量池后，s1、s2指向的是同一个内存地址，所以相等。


s1 == s3这个地方有个坑，s3虽然是动态拼接出来的字符串，但是所有参与拼接的部分都是已知的字面量，在编译期间，这种拼接会被优化，编译器直接帮你拼好，因此String s3 = "Hel" + "lo";在class文件中被优化成String s3 = "Hello";，所以s1 == s3成立。


s1 == s4当然不相等，s4虽然也是拼接出来的，但new String("lo")这部分不是已知字面量，是一个不可预料的部分，编译器不会优化，必须等到运行时才可以确定结果，结合字符串不变定理，鬼知道s4被分配到哪去了，所以地址肯定不同。配上一张简图理清思路：


     s1 == s9也不相等，道理差不多，虽然s7、s8在赋值的时候使用的字符串字面量，但是拼接成s9的时候，s7、s8作为两个变量，都是不可预料的，编译器毕竟是编译器，不可能当解释器用，所以不做优化，等到运行时，s7、s8拼接成的新字符串，在堆中地址不确定，不可能与方法区常量池中的s1地址相同。




s4 == s5已经不用解释了，绝对不相等，二者都在堆中，但地址不同。


s1 == s6这两个相等完全归功于intern方法，s5在堆中，内容为Hello ，intern方法会尝试将Hello字符串添加到常量池中，并返回其在常量池中的地址，因为常量池中已经有了Hello字符串，所以intern方法直接返回地址；而s1在编译期就已经指向常量池了，因此s1和s6指向同一地址，相等。


至此，我们可以得出三个非常重要的结论：


必须要关注编译期的行为，才能更好的理解常量池。


运行时常量池中的常量，基本来源于各个class文件中的常量池。


程序运行时，除非手动向常量池中添加常量(比如调用intern方法)，否则jvm不会自动添加常量到常量池。


以上所讲仅涉及字符串常量池，实际上还有整型常量池、浮点型常量池等等，但都大同小异，只不过数值类型的常量池不可以手动添加常量，程序启动时常量池中的常量就已经确定了，比如整型常量池中的常量范围：-128~127，只有这个范围的数字可以用到常量池。


实践


说了这么多理论，接下来让我们触摸一下真正的常量池。


前文提到过，class文件中存在一个静态常量池，这个常量池是由编译器生成的，用来存储java源文件中的字面量(本文仅仅关注字面量)，假设我们有如下java代码：


1 String s = "hi";


为了方便起见，就这么简单，没错！将代码编译成class文件后，用winhex打开二进制格式的class文件。如图：




简单讲解一下class文件的结构，开头的4个字节是class文件魔数，用来标识这是一个class文件，说白话点就是文件头，既：CA FE BA BE。


紧接着4个字节是java的版本号，这里的版本号是34，因为笔者是用jdk8编译的，版本号的高低和jdk版本的高低相对应，高版本可以兼容低版本，但低版本无法执行高版本。所以，如果哪天读者想知道别人的class文件是用什么jdk版本编译的，就可以看这4个字节。


接下来就是常量池入口，入口处用2个字节标识常量池常量数量，本例中数值为00 1A，翻译成十进制是26，也就是有25个常量，其中第0个常量是特殊值，所以只有25个常量。


常量池中存放了各种类型的常量，他们都有自己的类型，并且都有自己的存储规范，本文只关注字符串常量，字符串常量以01开头(1个字节)，接着用2个字节记录字符串长度，然后就是字符串实际内容。本例中为：01 00 02 68 69。


接下来再说说运行时常量池，由于运行时常量池在方法区中，我们可以通过jvm参数：-XX:PermSize、-XX:MaxPermSize来设置方法区大小，从而间接限制常量池大小。


假设jvm启动参数为：-XX:PermSize＝2M -XX:MaxPermSize＝2M，然后运行如下代码：




1 //保持引用，防止自动垃圾回收
2 List<String> list = new ArrayList<String>();
3
4 int i = 0;
5
6 while(true){
7     //通过intern方法向常量池中手动添加常量
8     list.add(String.valueOf(i++).intern());
9 }




程序立刻会抛出：Exception in thread "main" java.lang.outOfMemoryError: PermGen space异常。PermGen space正是方法区，足以说明常量池在方法区中。


在jdk8中，移除了方法区，转而用Metaspace区域替代，所以我们需要使用新的jvm参数：-XX:MaxMetaspaceSize=2M，依然运行如上代码，抛出：java.lang.OutOfMemoryError: Metaspace异常。同理说明运行时常量池是划分在Metaspace区域中。具体关于Metaspace区域的知识，请读者自行搜索。


本文所有代码均在jdk7、jdk8下测试通过，其他版本jdk可能会略有差异，请读者自行探索。


参考文献：《深入理解java虚拟机———jvm高级特性与最佳实践》


参考：http://www.cnblogs.com/iyangyuan/p/4631696.html


常量池再补充：


java中基本类型的包装类的大部分都实现了常量池技术，这些类是Byte,Short,Integer,Long,Character,Boolean,另外两种浮点数类型的包装类则没有实现。另外Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127时才可使用对象池，也即对象不负责创建和管理大于127的这些类的对象。（对于较小数值的整型，在处理自动装箱的时候，采用常量池里面的值以节省内存，而大数值则是重新new出来的。这里刚好是分界线。）


　　在C语言中，如果一个程序要调用其它库中的函数，在连接时，该函数在库中的位置（即相对于库文件开头的偏移量）会被写在程序中，在运行时，直接去这个地址调用函数；


　　而在Java语言中不是这样，一切都是动态的。编译时，如果发现对其它类方法的调用或者对其它类字段的引用的话，记录进class文件中的，只能是一个文本形式的符号引用，在连接过程中，虚拟机根据这个文本信息去查找对应的方法或字段。


　　所以，与Java语言中的所谓“常量”不同，class文件中的“常量”内容很非富，这些常量集中在class中的一个区域存放，一个紧接着一个，这里就称为“常量池”。


java中的常量池技术，是为了方便快捷地创建某些对象而出现的，当需要一个对象时，就可以从池中取一个出来（如果池中没有则创建一个），则在需要重复重复创建相等变量时节省了很多时间。常量池其实也就是一个内存空间，不同于使用new关键字创建的对象所在的堆空间。本文只从java使用者的角度来探讨java常量池技术，并不涉及常量池的原理及实现方法。个人认为，如果是真的专注java,就必须对这些细节方面有一定的了解。但知道它的原理和具体的实现方法则不是必须的。


常量池中对象和堆中的对象


[java] view

 plain copy


    

  1. public class Test{
    2. 

  2. Integer i1=new Integer(1);
    3. 

  3. Integer i2=new Integer(1);
    4. 

  4. //i1,i2分别位于堆中不同的内存空间
    5. 

  5. System.out.println(i1==i2);//输出false
    6. 

  6. Integer i3=1;
    7. 

  7. Integer i4=1;
    8. 

  8. //i3,i4指向常量池中同一个内存空间
    9. 

  9. System.out.println(i3==i4);//输出true
    10. 

  10. //很显然，i1,i3位于不同的内存空间
    11. 

  11. System.out.println(i1==i3);//输出false
    12. 

  12. }
    13. 




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


java中基本类型的包装类的大部分都实现了常量池技术，这些类是Byte,Short,Integer,Long,Character,Boolean,另外两种浮点数类型的包装类则没有实现。另外Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127时才可使用对象池，也即对象不负责创建和管理大于127的这些类的对象。以下是一些对应的测试代码：


[java] view

 plain copy


    

  1. public class Test{
    2. 

  2. public static void main(String[] args){
    3. 

  3. //5种整形的包装类Byte,Short,Integer,Long,Character的对象，
    4. 

  4. //在值小于127时可以使用常量池
    5. 

  5. Integer i1=127;
    6. 

  6. Integer i2=127;
    7. 

  7. System.out.println(i1==i2)//输出true
    8. 

  8. //值大于127时，不会从常量池中取对象
    9. 

  9. Integer i3=128;
    10. 

  10. Integer i4=128;
    11. 

  11. System.out.println(i3==i4)//输出false
    12. 

  12. //Boolean类也实现了常量池技术
    13. 

  13. Boolean bool1=true;
    14. 

  14. Boolean bool2=true;
    15. 

  15. System.out.println(bool1==bool2);//输出true
    16. 

  16. //浮点类型的包装类没有实现常量池技术
    17. 

  17. Double d1=1.0;
    18. 

  18. Double d2=1.0;
    19. 

  19. System.out.println(d1==d2)//输出false
    20. 

  20. }
    21. 

  21. }
    22. 




String也实现了常量池技术


String类也是java中用得多的类，同样为了创建String对象的方便，也实现了常量池的技术,测试代码如下:


[java] view

 plain copy


    

  1. public class Test{
    2. 

  2. public static void main(String[] args){
    3. 

  3. //s1,s2分别位于堆中不同空间
    4. 

  4. String s1=new String("hello");
    5. 

  5. String s2=new String("hello");
    6. 

  6. System.out.println(s1==s2)//输出false
    7. 

  7. //s3,s4位于池中同一空间
    8. 

  8. String s3="hello";
    9. 

  9. String s4="hello";
    10. 

  10. System.out.println(s3==s4);//输出true
    11. 

  11. }
    12. 

  12. }
    13. 




最后


细节决定成败，写代码更是如此。


在JDK5.0之前是不允许直接将基本数据类型的数据直接赋值给其对应地包装类的，如：Integer i = 5;


但是在JDK5.0中支持这种写法，因为编译器会自动将上面的代码转换成如下代码：Integer i=Integer.valueOf(5);


这就是Java的装箱.JDK5.0也提供了自动拆箱. Integer i =5;  int j = i;


Integer的封装：


[java] view

 plain copy


    

  1. public static Integer valueOf(int i) {
    2. 

  2. final int offset = 128;
    3. 

  3. if (i >= -128 && i <= 127) { // must cache
    4. 

  4. return IntegerCache.cache[i + offset];
    5. 

  5. }
    6. 

  6. return new Integer(i);
    7. 

  7. }
    8. 

  8. private static class IntegerCache {
    9. 

  9. private IntegerCache(){}
    10. 

  10. static final Integer cache[] = new Integer[-(-128) + 127 + 1];
    11. 

  11. static {
    12. 

  12. for(int i = 0; i < cache.length; i++)
    13. 

  13. cache[i] = new Integer(i - 128);
    14. 

  14. }
    15. 

  15. }
    16. 



由于cache[]在IntegerCache类中是静态数组，也就是只需要初始化一次，即static｛......｝部分，所以，如果Integer对象初始化时是-128~127的范围，就不需要再重新定义申请空间，都是同一个对象---在IntegerCache.cache中，这样可以在一定程度上提高效率。


参考：http://blog.csdn.net/olanlanxiari/article/details/8104505
				


				
时间： 2024-08-07 04:23:31 

		


		


	

	
	

		


		
Java核心知识点-JVM结构之常量池的相关文章


								

		

			

                Java核心知识点学习----多线程 倒计时记数器CountDownLatch和数据交换的Exchanger
			

		

		

									

				本文将要介绍的内容都是Java5中的新特性,一个是倒计时记数器---CountDownLatch,另一个是用于线程间数据交换的Exchanger. 一.CountDownLatch 1.什么是CountDownLatch? 倒计时计数器,调用CountDownLatch对象的CountDown()方法就将计数器减一,当计数到达0时,则所有等待者或者全部等待者开始执行. 2.如何用? new CountDownLatch(1); 直接new,其构造函数必须传一个int类型的参数,参数的意思是: c			

		

	

				

		

			

                Java核心知识点学习----多线程中的阻塞队列,ArrayBlockingQueue介绍
			

		

		

									

				1.什么是阻塞队列? 所谓队列,遵循的是先进先出原则(FIFO),阻塞队列,即是数据共享时,A在写数据时,B想读同一数据,那么就将发生阻塞了. 看一下线程的四种状态,首先是新创建一个线程,然后,通过start方法启动线程--->线程变为可运行可执行状态,然后通过数据产生共享,线程产生互斥---->线程状态变为阻塞状态---->阻塞状态想打开的话可以调用notify方法. 这里Java5中提供了封装好的类,可以直接调用然后构造阻塞状态,以保证数据的原子性. 2.如何实现? 主要是实现Blo			

		

	

				

		

			

                JVM内存结构和常量池
			

		

		

									

				1.虚拟机的构成 虚拟结主要由运行时数据区.执行引擎.类加载器三者构成,我们所说的JVM内存模型指的就是运行时数据区. 2.运行时数据区组成和各个区域的作用 运行时数据区可以分为线程共享和线程不共享两部分,其中堆内存和方法区线程共享,本地方法栈.虚拟机栈.程序计数器线程不共享. 2.1.程序计数器 程序计数器(Program Counter Register),也有称作为PC寄存器.想必学过汇编语言的朋友对程序计数器这个概念并不陌生,在汇编语言中,程序计数器是指CPU中的寄存器,它保存的是程序当			

		

	

				

		

			

                Java虚拟机OOM之运行时常量池溢出（5）
			

		

		

									

				如果要向运行时常量池中添加内容,最简单的做法就是使用 String.intern()这个 Native 方法.该方法的作用是:如果池中已经包含一个等于此 String 对象的字符串,则返回代表池中这个字符串的String 对象:否则,将此 String 对象包含的字符串添加到常量池中,并且返回此 String 对象的引用.由于常量池分配在方法区内,我们可以通过-XX:PermSize 和-XX:MaxPermSize 限制方法区的大小,从而间接限制其中常量池的容量代码运行时常量池导致的内存溢出异			

		

	

				

		

			

                Java中堆、栈、常量池等概念解析
			

		

		

									

				程序运行时,我们最好对数据保存到什么地方做到心中有数.特别要注意的是内存的分配.有六个地方都可以保存数据: (1) 寄存器 这是最快的保存区域,因为它位于和其他所有保存方式不同的地方:处理器内部.然而,寄存器的数量十分有限,所以寄存器是根据需要由编译器分配.我们对此没有直接的控制权,也不可能在自己的程序里找到寄存器存在的任何踪迹. (2) 栈(stack) 存放基本类型的变量数据和对象的引用,但对象本身不存放在栈中,而是存放在堆(new 出来的对象)或者常量池中(字符串常量对象存放在常量池中.)			

		

	

				

		

			

                java总结之基础类型与常量池
			

		

		

									

				1.基础类型有byte short int long char boolean float double八种. 其中byte short int long char 的包装类型是存放在常量池(用来维护该类型所用到常量的有序集合)中的,浮点类型未实现常量池. 常量池存放的是>=-128和<=127中的数据,当数据不在这个范围内时,则不在常量池中维护 Integer a=new Integer(128); Integer b=new Integer(128); a==b?false,由于a,b超出			

		

	

				

		

			

                JVM 运行时常量池（Runtime Constant Pool）
			

		

		

									

				基本特性: 方法区的一部分,在方法去中分配,加载泪或者接口后就创建运行时常量区. class文件每一个类或接口的常量池表(constant_pool table)的运行时表现形式, 包括编译期的数值字面量和运行期的方法或者字段引用 ref:class文件结构			

		

	

				

		

			

                java核心知识点 --- 线程池ThreadPool
			

		

		

									

				线程池是多线程学习中需要重点掌握的. 系统启动一个新线程的成本是比较高的,因为它涉及与操作系统交互.在这种情形下,使用线程池可以很好的提高性能,尤其是当程序中需要创建大量生存期很短暂的线程时,更应该考虑使用线程池. 一.如何创建线程池?? 在Java5之前,线程池都是开发才手动实现的,从Java5开始,Java内建支持线程池.主要是新增了一个executors工厂类来生产线程池. 1.newCachedThreadPool():创建一个具有缓存功能的线程池,系统根据需要创建线程,这些线程将会被缓			

		

	

				

		

			

                Java核心知识点-ClassLoader详解
			

		

		

									

				ClassLoader ClassLoader主要对类的请求提供服务,当JVM需要某类时,它根据名称向ClassLoader要求这个类,然后由ClassLoader返回这个类的class对象. 1.1 几个相关概念ClassLoader负责载入系统的所有Resources(Class,文件,来自网络的字节流等),通过ClassLoader从而将资源载入JVM 每个class都有一个reference,指向自己的ClassLoader.Class.getClassLoader() array的Cl