JVM学习之内存分配一

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了JVM学习之内存分配一相关的知识,希望对你有一定的参考价值。

转自:http://blog.csdn.net/mazhimazh/article/details/16879055,多谢博主分享    

    我们知道计算机的基本构成是:运算器、控制器、存储器、输入和输出设备,那这个JVM也是有这成套的元素,运算器是当然是交给硬件CPU还处理了,只是为了适应“一次编译,随处运行”的情况,需要做一个翻译动作,于是就用了JVM指令集,这与汇编的命令集有点类似,每一种汇编命令集针对一个系列的CPU,比如8086系列的汇编也是可以用在8088上的,但是就不能跑在8051上,而JVM的命令集则是可以到处运行的,因为JVM做了翻译,根据不同的CPU,翻译成不同的机器语言。其虚拟机的基本结构如下图所示。

技术分享技术分享

其中需要我们重点理解的就是Stack和Heap,也就是堆和栈,他们在实际的应用中非常的广泛。

1、栈

    Java栈是由许多栈帧(frame)组成,一个栈帧包含一个Java方法的调用状态。当现成调用一个Java方法时,JVM压入一个新的栈帧到该线程的Java栈中;当方法返回时,这个栈帧被从Java栈中弹出并抛弃。
  栈帧由三部分构成:局部变量区、操作数栈和帧数据区。

  • 局部变量区被组织为一个数组,该数组单个元素长度为一个JVM字(注意不是一个机器字),用于保存本地变量(Local Variables),包括输入参数和输出参数以及方法内的变量;
  • 操作数栈也是被组织为一个单位长度为一个JVM字的数组,不过该数组只能通过标准栈操作(push和pop)访问,该栈是被(逻辑上的)CPU的ALU唯一识别的操作数来源。当方法返回值时,通常都是从栈中弹出一个数据来返回。
  • 帧数据区保存一些数据来支持常量池解析、正常方法返回以及异常派发机制。

 

  如有分别存在局部变量区的a,b,c,要计算c=a+b,则使用4条指令:

  1. 读局部变量区[0]的值,压入操作数栈;
  2. 读局部变量区[1]的值,压入操作数栈;
  3. 弹出操作数栈栈顶值,再弹出操作数栈栈顶值,相加,把结果压入操作数栈;
  4. 弹出操作数栈栈顶值,写入局部变量区[2]。
1 public class test {  
2     public static void main(String args[]) {  
3         int a = 2;  
4         int b = 3;  
5         int c = a + b;  
6     }  
7 } 

其Class文件的代码如下所示.

1 0  iconst_2  
2 1  istore_1 [a]  
3 2  iconst_3  
4 3  istore_2 [b]  
5 4  iload_1 [a]  
6 5  iload_2 [b]  
7 6  iadd  
8 7  istore_3 [c]  
9 8  return  
 

可以看到,是先将值为2和2存储到局部变量区,然后分别弹出压入操作数栈,最后进行相加操作,将结果填入局部变量区,返回操作数栈中的数据。

2、堆  

    一个JVM实例只存在一个堆类存,堆内存的大小是可以调节的。类加载器读取了类文件后,需要把类、方法、常变量放到堆内存中,以方便执行器执行。 一般的,对象的内存分配都是在堆上进行。

    在Java程序运行的过程中,会产生大量的对象,其中有些对象是与业务信息相关,比如Http请求中的Session对象、线程、Socket连接,这类对象跟业务直接挂钩,因此生命周期比较长。还有一些对象,主要是程序运行过程中生成的临时变量,这些对象生命周期会比较短,比如:String对象,由于其不变类的特性,系统会产生大量的这些对象,有些对象甚至只用一次即可回收。

    如上可以看出,不同的对象的生命周期是不一样的。因此,不同生命周期的对象可以采取不同的收集方式,以便提高回收效率。 虚拟机中的共划分为三个代:年轻代(Young Generation)、年老点(Old Generation)和持久代(Permanent Generation)。其中持久代主要存放的是Java类信息,与垃圾收集要收集的Java对象关系不大。年轻代和年老代的划分是对垃圾收集影响比较大的。如下图。

技术分享

 

新生代(Young Generation):

    对象被创建时,内存的分配首先发生在新生区(大对象可以直接被创建在新生区),大部分的对象在创建后很快就不再使用,因此很快变得不可达,于是被新生区的GC机制清理掉。

  新生区上的内存分配是这样的,新生区可以分为3个区域:Eden区(表示内存首次分配的区域)和两个存活区(Survivor 0 、Survivor 1)。其内存的分配及回收过程应用的主要策略算法就是停止-复制(Stop-and-copy)清理法,但是这不代表着停止 - 复制清理法很高效。。

  1. 绝大多数刚创建的对象会被分配在Eden区,其中的大多数对象很快就会消亡。Eden区是连续的内存空间,因此在其上分配内存极快;                                      技术分享
  2. 当Eden区满的时候,执行Minor GC,将消亡的对象清理掉,并将剩余的对象复制到一个存活区Survivor0(此时,Survivor1是空白的,两个Survivor总有一个是空白的),此后,每次Eden区满了,就执行一次Minor GC,并将剩余的对象都添加到Survivor0;                  技术分享
  3. 当Survivor0也满的时候,将其中仍然活着的对象直接复制到Survivor1,以后Eden区执行Minor GC后,就将剩余的对象添加Survivor1(此时,Survivor0是空白的)。                                                                          技术分享                                                                                                                                   技术分享
  4. 当两个存活区切换了几次(HotSpot虚拟机默认15次,用-XX:MaxTenuringThreshold控制,大于该值进入老年代)之后,仍然存活的对象(其实只有一小部分,比如,我们自己定义的对象),将被复制到老年代。                                                         技术分享   

   在Eden区,HotSpot虚拟机使用了两种技术来加快内存分配。分别是bump-the-pointer和TLAB(Thread-Local Allocation Buffers),这两种技术的做法分别是:由于Eden区是连续的,因此bump-the-pointer技术的核心就是跟踪最后创建的一个对象,在对象创建时,只需要检查最后一个对象后面是否有足够的内存即可,从而大大加快内存分配速度;而对于TLAB技术是对于多线程而言的,将Eden区分为若干段,每个线程使用独立的一段,避免相互影响。TLAB结合bump-the-pointer技术,将保证每个线程都使用Eden区的一段,并快速的分配内存。

年老代(Young Generation):

    对象如果在年轻代存活了足够长的时间而没有被清理掉(即在几次Young GC后存活了下来),则会被复制到年老代,年老代的空间一般比年轻代大,能存放更多的对象,在年老代上发生的GC次数也比年轻代少。当年老代内存不足时,将执行Major GC,也叫 Full GC。 

   如果对象比较大(比如长字符串或大数组),Young空间不足,则大对象会直接分配到老年代上。

    可能存在年老代对象引用新生代对象的情况,如果需要执行Young GC,则可能需要查询整个老年代以确定是否可以清理回收,这显然是低效的。解决的方法是,年老代中维护一个512 byte的块——”card table“,所有老年代对象引用新生代对象的记录都记录在这里。Young GC时,只要查这里即可,不用再去查全部老年代,因此性能大大提高。

   老年代存储的对象比年轻代多得多,而且不乏大对象,对老年代进行内存清理时,如果使用停止-复制算法,则相当低效。一般,老年代用的算法是标记-整理算法。

技术分享

 技术分享技术分享

       分两阶段,第一阶段从根节点开始标记所有被引用对象,第二阶段遍历整个堆,把清除未标记对象并且把存活对象“压缩”到堆的其中一块,按顺序排放。此算法不会产生碎片。

    在发生Minor GC时,虚拟机会检查每次晋升进入老年代的大小是否大于老年代的剩余空间大小,如果大于,则直接触发一次Full GC,否则,就查看是否设置了-XX:+HandlePromotionFailure(允许担保失败),如果允许,则只会进行Minor GC,此时可以容忍内存分配失败;如果不允许,则仍然进行Full GC(这代表着如果设置-XX:+Handle PromotionFailure,则触发MinorGC就会同时触发Full GC,哪怕老年代还有很多内存,所以,最好不要这样做)。

持久代(Permanent Generation):

       用于存放静态文件,如今Java类、方法等。持久代对垃圾回收没有显著影响,但是有些应用可能动态生成或者调用一些class,例如Hibernate等,在这种时候需要设置一个比较大的持久代空间来存放这些运行过程中新增的类。持久代大小通过-XX:MaxPermSize=<N>进行设置。

 永久代的回收有两种:常量池中的常量,无用的类信息,常量的回收很简单,没有引用了就可以被回收。对于无用的类进行回收,必须保证3点:

  1. 类的所有实例都已经被回收
  2. 加载类的ClassLoader已经被回收
  3. 类对象的Class对象没有被引用(即没有通过反射引用该类的地方)
     永久代的回收并不是必须的,可以通过参数来设置是否对类进行回收。HotSpot提供-Xnoclassgc进行控制使用
     -verbose,-XX:+TraceClassLoading、-XX:+TraceClassUnLoading可以查看类加载和卸载信息
     -verbose、-XX:+TraceClassLoading可以在Product版HotSpot中使用;
     -XX:+TraceClassUnLoading需要fastdebug版HotSpot支持

3、栈与堆

1)栈是运行时的单位,而堆是存储的单位。

    栈解决程序的运行问题,即程序如何执行,或者说如何处理数据;堆解决的是数据存储的问题,即数据怎么放、放在哪儿。

    在Java中一个线程就会相应有一个线程栈与之对应,这点很容易理解,因为不同的线程执行逻辑有所不同,因此需要一个独立的线程栈。而堆则是所有线程共享的。栈因为是运行单位,因此里面存储的信息都是跟当前线程(或程序)相关信息的。包括局部变量、程序运行状态、方法返回值等等;而堆只负责存储对象信息。

2)为什么要把堆和栈区分出来呢?栈中不是也可以存储数据吗?

    第一,从软件设计的角度看,栈代表了处理逻辑,而堆代表了数据。这样分开,使得处理逻辑更为清晰。分而治之的思想。这种隔离、模块化的思想在软件设计的方方面面都有体现。

    第二,堆与栈的分离,使得堆中的内容可以被多个栈共享(也可以理解为多个线程访问同一个对象)。这种共享的收益是很多的。一方面这种共享提供了一种有效的数据交互方式(如:共享内存),另一方面,堆中的共享常量和缓存可以被所有栈访问,节省了空间。

    第三,栈因为运行时的需要,比如保存系统运行的上下文,需要进行地址段的划分。由于栈只能向上增长,因此就会限制住栈存储内容的能力。而堆不同,堆中的对象是可以根据需要动态增长的,因此栈和堆的拆分,使得动态增长成为可能,相应栈中只需记录堆中的一个地址即可。

    第四,面向对象就是堆和栈的完美结合。其实,面向对象方式的程序与以前结构化的程序在执行上没有任何区别。但是,面向对象的引入,使得对待问题的思考方式发生了改变,而更接近于自然方式的思考。当我们把对象拆开,你会发现,对象的属性其实就是数据,存放在堆中;而对象的行为(方法),就是运行逻辑,放在栈中。我们在编写对象的时候,其实即编写了数据结构,也编写的处理数据的逻辑。不得不承认,面向对象的设计,确实很美。

3)堆中存什么?栈中存什么?

    堆中存的是对象。栈中存的是基本数据类型和堆中对象的引用。一个对象的大小是不可估计的,或者说是可以动态变化的,但是在栈中,一个对象只对应了一个4btye的引用(堆栈分离的好处)。

    为什么不把基本类型放堆中呢?因为其占用的空间一般是1~8个字节——需要空间比较少,而且因为是基本类型,所以不会出现动态增长的情况——长度固定,因此栈中存储就够了,如果把他存在堆中是没有什么意义的(还会浪费空间,后面说明)。可以这么说,基本类型和对象的引用都是存放在栈中,而且都是几个字节的一个数,因此在程序运行时,他们的处理方式是统一的。但是基本类型、对象引用和对象本身就有所区别了,因为一个是栈中的数据一个是堆中的数据。最常见的一个问题就是,Java中参数传递时的问题。

4)Java中的参数传递时传值呢?还是传引用?(引用类型包括:类类型,接口类型和数组)

    在运行栈中,基本类型和引用的处理是一样的,都是传值,所以,如果是传引用的方法调用,也同时可以理解为“传引用值”的传值调用,即引用的处理跟基本类型是完全一样的。但是当进入被调用方法时,被传递的这个引用的值,被程序解释(或者查找)到堆中的对象,这个时候才对应到真正的对象。如果此时进行修改,修改的是引用对应的对象,而不是引用本身,即:修改的是堆中的数据。所以这个修改是可以保持的了。

 1 public class test2 {  
 2     public void change(StringBuffer a, int b,String c) {  
 3         a.append("xxxx");  
 4         b = 2;  
 5         c+="nnn";  
 6                 System.out.println(c);//mmmmnnn  
 7     }  
 8     public static void main(String[] args) {  
 9         StringBuffer a=new StringBuffer("yyyy");  
10         String c="mmmm";  
11         int b=3;  
12         new test2().change(a, b,c);  
13         System.out.println(a);// yyyyxxxx  
14         System.out.println(b);// 3  
15         System.out.println(c);// mmmm  
16     }  
17   
18 }  
 

    Java中,栈的大小通过-Xss来设置,当栈中存储数据比较多时,需要适当调大这个值,否则会出现java.lang.StackOverflowError异常。常见的出现这个异常的是无法返回的递归,因为此时栈中保存的信息都是方法返回的记录点。

 

以上是关于JVM学习之内存分配一的主要内容,如果未能解决你的问题,请参考以下文章

深入理解JVM之JVM内存区域与内存分配

JVM学习-之对象的创建和内存分配

深入理解JVM之JVM内存区域与内存分配

JVM学习之内存分配和垃圾回收

Jvm(32),理解升级----(挺不错的)图解深入理解JVM之JVM内存区域与内存分配

JVM之垃圾收集器 (GC) 与内存分配策略