java JVM的内存区域（运行时数据区域）

时间  2019-11-09
标签 java jvm 内存 区域 运行时 数据 栏目 Java 繁體版
原文   原文链接

JVM的内存形式： html

（1）方法区：存放了要加载的类的信息（名称，修饰符等）、类中的静态变量、类中定义为final的变量、类中Field信息、类中的方法信息，当开发人员经过Class对象的getName、isInterface方法来获取信息时候，这些信息都来源于方法区。方法区域也是全局共享的，在必定条件下它也会被GC，当方法区域要使用的内存超过其运行的大小时，会抛出OutOfMemory信息。调节大小使用-XX:PerSize和-XX:MaxPerSize java

（2）堆：用于存入对象实例和数组值，全部的线程共享堆空间。 程序员

注意建立出来的对象只包含属于各自的成员变量，并不包括成员方法。由于同一个类的对象拥有各自的成员变量，存储在各自的堆中，可是他们共享该类的方法，并非每建立一个对象就把成员方法复制一次。对象使用方法的时候方法才被压入栈，方法不使用则不占用内存。调节大小使用：-Xms和-Xmx 算法

（3）本地方法栈：用于支持native方法的执行，存储了每一个native方法调用的状态。 windows

（4）PC寄存器和JVM方法栈：每一个线程会建立本身的PC寄存器和JVM方法栈，因此PC寄存器和JVM方法栈为线程所私有。PC存放下一条指令在方法内的偏移量，栈中存放栈帧，每一个方法每次调用都会产生栈帧，栈帧主要是分为局部变量区和操做数栈两个部分。局部变量区用于存放方法中的局部变量和参数，操做数栈存放方法执行过程当中产生的中间结果。栈帧里面还有一些杂用空间，例如方法已经解析常量池的引用。当JVM方法栈空间不足时，会抛出StackOverflowError错误。 数组


　　本文引用自：深刻理解Java虚拟机的第2章内容（全面） 安全

　　Java与C++之间有一堵由内存动态分配和垃圾收集技术所围成的高墙，墙外面的人想进去，墙里面的人却想出来。 服务器

　　概述：

　　对于从事C和C++程序开发的开发人员来讲，在内存管理领域，他们既是拥有最高权力的皇帝，又是从事最基础工做的劳动人民—既拥有每 数据结构

一个对象的“全部权”，又担负着每个对象生命开始到终结的维护责任。 多线程

　　对于Java程序员来讲，在虚拟机的自动内存管理机制的帮助下，再也不须要为每个new操做去写配对的delete/free代码，并且不容易出现

内存泄漏和内存溢出问题，看起来由虚拟机管理内存一切都很美好。不过，也正是由于Java程序员把内存控制的权力交给了Java虚拟机，一旦

出现内存泄漏和溢出方面的问题，若是不了解虚拟机是怎样使用内存的，那排查错误将会成为一项异常艰难的工做。

　　运行时数据区域

　　Java虚拟机在执行Java程序的过程当中会把它所管理的内存划分为若干个不一样的数据区域。这些区域都有各自的用途，以及建立和销毁的时

间，有的区域随着虚拟机进程的启动而存在，有些区域则是依赖用户线程的启动和结束而创建和销毁。根据《Java虚拟机规范（第2版）》的规

定，Java虚拟机所管理的内存将会包括如下几个运行时数据区域，以下图所示：

　　　　　　　　　　

　　程序计数器　　　　　

　　程序计数器（Program Counter Register）是一块较小的内存空间，它的做用能够看作是当前线程所执行的字节码的行号指示器。在虚拟

机的概念模型里（仅是概念模型，各类虚拟机可能会经过一些更高效的方式去实现），字节码解释器工做时就是经过改变这个计数器的值来选取

下一条须要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都须要依赖这个计数器来完成。 因为Java虚拟机的多线

程是经过线程轮流切换并分配处理器执行时间的方式来实现的，在任何一个肯定的时刻，一个处理器（对于多核处理器来讲是一个内

核）只会执行一条线程中的指令。所以，为了线程切换后能恢复到正确的执行位置，每条线程都须要有一个独立的程序计数器，各条

线程之间的计数器互不影响，独立存储，咱们称这类内存区域为“线程私有”的内存。 若是线程正在执行的是一个Java方法，这个计数器

记录的是正在执行的虚拟机字节码指令的地址；若是正在执行的是Natvie方法，这个计数器值则为空（Undefined）。此内存区域是惟一一个

在Java虚拟机规范中没有规定任何OutOfMemoryError状况的区域。

　　Java虚拟机栈

　　与程序计数器同样，Java虚拟机栈（Java Virtual Machine Stacks）也是线程私有的，它的生命周期与线程相同。虚拟机栈描述的是Java

方法执行的内存模型：每一个方法被执行的时候都会同时建立一个栈帧（Stack Frame）用于存储局部变量表、操做栈、动态连接、方法出口

等信息。每个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。

　　常常有人把Java内存区分为堆内存（Heap）和栈内存（Stack），这种分法比较粗糙，Java内存区域的划分实际上远比这复杂。这种划分

方式的流行只能说明大多数程序员最关注的、与对象内存分配关系最密切的内存区域是这两块。其中所指的“堆”在后面会专门讲述，而所指

的“栈”就是如今讲的虚拟机栈，或者说是虚拟机栈中的局部变量表部分。

　　局部变量表存放了编译期可知的各类基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用

（reference类型），它不等同于对象自己，根据不一样的虚拟机实现，它多是一个指向对象起始地址的引用指针，也可能指向一个表明对象的

句柄或者其余与此对象相关的位置）和returnAddress类型（指向了一条字节码指令的地址）。

　　其中64位长度的long和double类型的数据会占用2个局部变量空间（Slot），其他的数据类型只占用1个。局部变量表所需的内存

空间在编译期间完成分配，当进入一个方法时，这个方法须要在帧中分配多大的局部变量空间是彻底肯定的，在方法运行期间不会改

变局部变量表的大小。 在Java虚拟机规范中，对这个区域规定了两种异常情况：若是线程请求的栈深度大于虚拟机所容许的深度，将抛出

StackOverflowError异常；若是虚拟机栈能够动态扩展（当前大部分的Java虚拟机均可动态扩展，只不过Java虚拟机规范中也容许固定长度的

虚拟机栈），当扩展时没法申请到足够的内存时会抛出OutOfMemoryError异常。

　　本地方法栈

　　本地方法栈（Native Method Stacks）与虚拟机栈所发挥的做用是很是类似的，其区别不过是虚拟机栈为虚拟机执行Java方法（也就是字

节码）服务，而本地方法栈则是为虚拟机使用到的Native方法服务。虚拟机规范中对本地方法栈中的方法使用的语言、使用方式与数据结构并没

有强制规定，所以具体的虚拟机能够自由实现它。甚至有的虚拟机（譬如Sun HotSpot虚拟机）直接就把本地方法栈和虚拟机栈合二为一。与

虚拟机栈同样，本地方法栈区域也会抛出StackOverflowError和OutOfMemoryError异常。

　　Java堆

　　对于大多数应用来讲，Java堆（Java Heap）是Java虚拟机所管理的内存中最大的一块。Java堆是被全部线程共享的一块内存区域，在虚拟机启动时建立。此内存区域的惟一目的就是存放对象实例，几乎全部的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：全部的对象实例以及数组都要在堆上分配，可是随着JIT编译器的发展与逃逸分析技术的逐渐成熟，栈上分配、标量替换优化技术将会致使一些微妙的变化发生，全部的对象都分配在堆上也渐渐变得不是那么“绝对”了。

　　Java堆是垃圾收集器管理的主要区域，所以不少时候也被称作“GC堆”（Garbage Collected Heap，幸亏国内没翻译成“垃圾堆”）。若是从内存回收的角度看，因为如今收集器基本都是采用的分代收集算法，因此Java堆中还能够细分为：新生代和老年代；再细致一点的有Eden空间、From Survivor空间、To Survivor空间等。若是从内存分配的角度看，线程共享的Java堆中可能划分出多个线程私有的分配缓冲区（Thread Local Allocation Buffer，TLAB）。不过，不管如何划分，都与存放内容无关，不管哪一个区域，存储的都仍然是对象实例，进一步划分的目的是为了更好地回收内存，或者更快地分配内存。在本章中，咱们仅仅针对内存区域的做用进行讨论，Java堆中的上述各个区域的分配和回收等细节将会是下一章的主题。

　　根据Java虚拟机规范的规定，Java堆能够处于物理上不连续的内存空间中，只要逻辑上是连续的便可，就像咱们的磁盘空间同样。在实现时，既能够实现成固定大小的，也能够是可扩展的，不过当前主流的虚拟机都是按照可扩展来实现的（经过-Xmx和-Xms控制）。若是在堆中没有内存完成实例分配，而且堆也没法再扩展时，将会抛出OutOfMemoryError异常。

　　方法区

　　方法区（Method Area）与Java堆同样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，可是它却有一个别名叫作Non-Heap（非堆），目的应该是与Java堆区分开来。

　　对于习惯在HotSpot虚拟机上开发和部署程序的开发者来讲，不少人愿意把方法区称为“永久代”（Permanent Generation），本质上二者并不等价，仅仅是由于HotSpot虚拟机的设计团队选择把GC分代收集扩展至方法区，或者说使用永久代来实现方法区而已。对于其余虚拟机（如BEA JRockit、IBM J9等）来讲是不存在永久代的概念的。即便是HotSpot虚拟机自己，根据官方发布的路线图信息，如今也有放弃永久代并“搬家”至Native Memory来实现方法区的规划了。

　　Java虚拟机规范对这个区域的限制很是宽松，除了和Java堆同样不须要连续的内存和能够选择固定大小或者可扩展外，还能够选择不实现垃圾收集。相对而言，垃圾收集行为在这个区域是比较少出现的，但并不是数据进入了方法区就如永久代的名字同样“永久”存在了。这个区域的内存回收目标主要是针对常量池的回收和对类型的卸载，通常来讲这个区域的回收“成绩”比较难以使人满意，尤为是类型的卸载，条件至关苛刻，可是这部分区域的回收确实是有必要的。在Sun公司的BUG列表中，曾出现过的若干个严重的BUG就是因为低版本的HotSpot虚拟机对此区域未彻底回收而致使内存泄漏。 根据Java虚拟机规范的规定，当方法区没法知足内存分配需求时，将抛出OutOfMemoryError异常。

　　运行时常量池

　　运行时常量池（Runtime Constant Pool）是方法区的一部分。Class文件中除了有类的版本、字段、方法、接口等描述等信息外，还有一项信息是常量池（Constant Pool Table），用于存放编译期生成的各类字面量和符号引用，这部份内容将在类加载后存放到方法区的运行时常量池中。 Java虚拟机对Class文件的每一部分（天然也包括常量池）的格式都有严格的规定，每个字节用于存储哪一种数据都必须符合规范上的要求，这样才会被虚拟机承认、装载和执行。但对于运行时常量池，Java虚拟机规范没有作任何细节的要求，不一样的提供商实现的虚拟机能够按照本身的须要来实现这个内存区域。不过，通常来讲，除了保存Class文件中描述的符号引用外，还会把翻译出来的直接引用也存储在运行时常量池中。 运行时常量池相对于Class文件常量池的另一个重要特征是具有动态性，Java语言并不要求常量必定只能在编译期产生，也就是并不是预置入Class文件中常量池的内容才能进入方法区运行时常量池，运行期间也可能将新的常量放入池中，这种特性被开发人员利用得比较多的即是String类的intern()方法。 既然运行时常量池是方法区的一部分，天然会受到方法区内存的限制，当常量池没法再申请到内存时会抛出OutOfMemoryError异常。

　　对象访问

　　介绍完Java虚拟机的运行时数据区以后，咱们就能够来探讨一个问题：在Java语言中，对象访问是如何进行的？对象访问在Java语言中无处不在，是最普通的程序行为，但即便是最简单的访问，也会却涉及Java栈、Java堆、方法区这三个最重要内存区域之间的关联关系，以下面的这句代码：

　　　　　　　　　　Object obj = new Object();

假设这句代码出如今方法体中，那“Object obj”这部分的语义将会反映到Java栈的本地变量表中，做为一个reference类型数据出现。而“new Object()”这部分的语义将会反映到Java堆中，造成一块存储了Object类型全部实例数据值（Instance Data，对象中各个实例字段的数据）的结构化内存，根据具体类型以及虚拟机实现的对象内存布局（Object Memory Layout）的不一样，这块内存的长度是不固定的。另外，在Java堆中还必须包含能查找到此对象类型数据（如对象类型、父类、实现的接口、方法等）的地址信息，这些类型数据则存储在方法区中。

　　因为reference类型在Java虚拟机规范里面只规定了一个指向对象的引用，并无定义这个引用应该经过哪一种方式去定位，以及访问到Java堆中的对

象的具体位置，所以不一样虚拟机实现的对象访问方式会有所不一样，主流的访问方式有两种：使用句柄和直接指针。 若是使用句柄访问方式，Java堆中将会划分出一块内存来做为句柄池，reference中存储的就是对象的句柄地址，而句柄中包含了对象实例数据和类型数据各自的具体地址信息，以下图所示：

　　　　　　

　　若是使用的是直接指针访问方式，Java 堆对象的布局中就必须考虑如何放置访问类型数据的相关信息，reference中直接存储的就是对象地址，以下

图所示：

　　　　　　

　　这两种对象的访问方式各有优点，使用句柄访问方式的最大好处就是reference中存储的是稳定的句柄地址，在对象被移动（垃圾收集时移动对象是很是广泛的行为）时只会改变句柄中的实例数据指针，而reference自己不须要被修改。使用直接指针访问方式的最大好处就是速度更快，它节省了一次指针定位的时间开销，因为对象的访问在Java中很是频繁，所以这类开销聚沙成塔后也是一项很是可观的执行成本。就本书讨论的主要虚拟机Sun HotSpot而言，它是使用第二种方式进行对象访问的，但从整个软件开发的范围来看，各类语言和框架使用句柄来访问的状况也十分常见。


问题：

问题一：对象引用的内存结构是什么？

在Java中，对象的引用其实是指向一个句柄的指针，该句柄包含一对指针，一个指针指向一张表，实际上该表也有两个指针（一个指针指向了包含了对象的方法表，另外一个指向了对象类型，代表该对象所属的类型），另外一个指针指向一块从Java堆中分配的内存空间，该空间用于存储对象数据。

参考:

Java内存管理：深刻Java内存区域:http://www.cnblogs.com/gw811/archive/2012/10/18/2730117.html（详细）

运行时数据区：http://bhsc-happy.iteye.com/blog/332723

  1. 当Java虚拟机运行时，它须要内存来存取不少东西。例如，字节码，从已经装载的class文件中获得的其余信息，程序建立的对象，传递给方法的参数，返回值，局部变量，已经运算的中间结果等。Java虚拟机把这些数据都组织到几个“运行时数据区”，以便于管理，主要包括方法区、堆、Java栈、PC寄存器、本地方法栈。
  4. 方法区
  6. 在Java虚拟机中，关于被装载的类型的信息存储在一个逻辑上被称为方法区的内存中。当虚拟机装载某个类型时，它使用类装载器定位相应的class文件，而后读入这个class文件--------一个线性二进制数据流--------而后把它传输到虚拟机中。紧接着虚拟机提取其中的类型信息，并将这些信息存储到方法区。该类型中的类（静态）变量一样也存储在方法区中。
  8. 因为全部线程都共享方法区，所以它们对方法区数据的访问必须被设计是线程安全的。好比，假设同时两个线程都企图访问一个名为Lava的类，而这个类尚未内装载入虚拟机，那么，这时应该只有一个线程去装载它，而另外一个线程则只能等待。
  10. 对每一个装载的类型，虚拟机都会在方法区中存储一下类型信息：
  12. l 这个类型的全限定名
  13. l 这个类型的直接超类的全限定名（除了Object）
  14. l 这个类型的是类类型仍是接口类型
  15. l 这个类型的访问修饰符
  16. l 任何直接超接口的全限定名的有序列表
  17. 除了上面的基本信息之外，虚拟机还得为每一个被装载的类型存储如下信息：
  19. l 该类型的常量池
  20. l 字段信息
  21. l 方法信息
  22. l 除了常量之外的全部类变量
  23. l 一个到ClassLoader的引用
  24. l 一个到Class类的引用
  27. 指向ClassLoader的引用
  29. 每一个类型被装载的时候，虚拟机必须跟踪它是由启动类装载器仍是由用户自定义类装载器装载的。若是是用户自定义类装载器装载的，那么虚拟机必须在类型信息中存储对该类型装载器的引用。这是做为方法表中的类型数据的一部分保存的。
  31. 虚拟机会在动态链接期间使用这个信息。当某个类型引用另外一个类型的时候，虚拟机会请求装载发起引用的类装载器来装载被引用的类型。这个动态链接的过程，对于虚拟机分离命名空间的方式也是相当重要的。为了可以正确执行动态链接以及维护多个命名空间，虚拟机须要在方法表中得知每一个类都是哪一个类装载器装载的。
  35. 指向Class的引用
  37. 对于每一个被装载的类型（无论是类仍是接口），虚拟机都会相应地为它在堆上建立一个java.lang.Class类的实例，并且虚拟机还必须以某种方式把这个实例和存储在方法区中的类型数据关联起来。
  39. 在程序中，可使用指向Class对象的引用。Class类中的两个方法能够获得任何已装载的类的Class实例的引用。分别是Class.forName(“”)以及Class.getClass()。
  41. 给出一个Class对象的引用，就能够经过Class类中的定义的方法来找出这个类型的相关信息。若是查看这些方法会很快意思到，Class类使得运行程序能够访问方法区中保存的信息。下面的是Class类中声明的方法：
  43. public string getName(); 返回类的全限定名
  44. public Class getSuperClass(); 返回类型的直接超类实例（object或者接口返回null）
  45. public boolean isInterface(); 判断该类型是不是接口
  46. public Class[] getInterfaces(); 返回一个Class对象数组，每一个Class对象对应一个直接超类接口，若是该类型没有直接超接口，getInterfaces（）返回一个0长度数组
  47. public ClassLoader getClassLoader(); 返回该类型的ClassLoader对象的引用
  51. 堆
  53. Java程序在运行时建立的全部类实或数组都放在同一个堆中。而一个Java虚拟实例中只存在一个堆空间，所以全部线程都将共享这个堆。
  55. Java对象中包含的基本数据由他所属的类及其全部超类声明的实例变量组成。只要有一个对象引用，虚拟机就必须可以快速的定位对象实例的数据。另外，它也必须能经过该对象引用访问相应的类数据（存储于方法区的类型信息）。所以在对象中一般会有一个指向方法区的指针。
  57. 程序计数器
  59. 每一个运行中的Java程序，每个线程都有它本身的PC寄存器，也是该线程启动时建立的。PC寄存器的内容老是指向下一条将被执行指令的饿“地址”，这里的“地址”能够是一个本地指针，也能够是在方法区中相对应于该方法起始指令的偏移量。
  61. Java栈
  63. Java栈以帧为单位保存线程的运行状态。虚拟机只会直接对Java栈执行两种操做：以帧为单位的压栈或出栈。
  65. 和方法区和堆同样，Java栈和帧在内存中也没必要是连续的。帧能够分布在连续的栈里，也能够分布在堆里，或者二者兼有的。
  67. 栈帧
  69. 栈帧由三部分组成：局部变量、操做数栈和帧数据区。
  71. 当虚拟机调用一个Java方法时，它从对应类的而类型信息中获得此方法的局部变量区和操做数栈的大小，并据此分配栈帧内存，而后压入Java栈中。
  73. 局部变量：存放局部变量和方法参数
  74. 操做数栈：线程的工做区，用来存放运算过程当中的临时数据
  75. 帧数据区：保存支持常量解析、正常方法返回以及异常派发机制的数据 
当Java虚拟机运行时，它须要内存来存取不少东西。例如，字节码，从已经装载的class文件中获得的其余信息，程序建立的对象，传递给方法的参数，返回值，局部变量，已经运算的中间结果等。Java虚拟机把这些数据都组织到几个“运行时数据区”，以便于管理，主要包括方法区、堆、Java栈、PC寄存器、本地方法栈。
 
 
方法区
 
      在Java虚拟机中，关于被装载的类型的信息存储在一个逻辑上被称为方法区的内存中。当虚拟机装载某个类型时，它使用类装载器定位相应的class文件，而后读入这个class文件--------一个线性二进制数据流--------而后把它传输到虚拟机中。紧接着虚拟机提取其中的类型信息，并将这些信息存储到方法区。该类型中的类（静态）变量一样也存储在方法区中。
 
       因为全部线程都共享方法区，所以它们对方法区数据的访问必须被设计是线程安全的。好比，假设同时两个线程都企图访问一个名为Lava的类，而这个类尚未内装载入虚拟机，那么，这时应该只有一个线程去装载它，而另外一个线程则只能等待。
 
       对每一个装载的类型，虚拟机都会在方法区中存储一下类型信息：
 
l  这个类型的全限定名
l  这个类型的直接超类的全限定名（除了Object）
l  这个类型的是类类型仍是接口类型
l  这个类型的访问修饰符
l  任何直接超接口的全限定名的有序列表
除了上面的基本信息之外，虚拟机还得为每一个被装载的类型存储如下信息：
 
l  该类型的常量池
l  字段信息
l  方法信息
l  除了常量之外的全部类变量
l  一个到ClassLoader的引用
l  一个到Class类的引用
 
      
指向ClassLoader的引用
 
       每一个类型被装载的时候，虚拟机必须跟踪它是由启动类装载器仍是由用户自定义类装载器装载的。若是是用户自定义类装载器装载的，那么虚拟机必须在类型信息中存储对该类型装载器的引用。这是做为方法表中的类型数据的一部分保存的。
 
       虚拟机会在动态链接期间使用这个信息。当某个类型引用另外一个类型的时候，虚拟机会请求装载发起引用的类装载器来装载被引用的类型。这个动态链接的过程，对于虚拟机分离命名空间的方式也是相当重要的。为了可以正确执行动态链接以及维护多个命名空间，虚拟机须要在方法表中得知每一个类都是哪一个类装载器装载的。
 
 
 
指向Class的引用
 
对于每一个被装载的类型（无论是类仍是接口），虚拟机都会相应地为它在堆上建立一个java.lang.Class类的实例，并且虚拟机还必须以某种方式把这个实例和存储在方法区中的类型数据关联起来。
 
       在程序中，可使用指向Class对象的引用。Class类中的两个方法能够获得任何已装载的类的Class实例的引用。分别是Class.forName(“”)以及Class.getClass()。
 
       给出一个Class对象的引用，就能够经过Class类中的定义的方法来找出这个类型的相关信息。若是查看这些方法会很快意思到，Class类使得运行程序能够访问方法区中保存的信息。下面的是Class类中声明的方法：
 
public string getName();                     返回类的全限定名
public Class getSuperClass();        返回类型的直接超类实例（object或者接口返回null）
public boolean isInterface();         判断该类型是不是接口
public Class[] getInterfaces();              返回一个Class对象数组，每一个Class对象对应一个直接超类接口，若是该类型没有直接超接口，getInterfaces（）返回一个0长度数组
public ClassLoader getClassLoader();    返回该类型的ClassLoader对象的引用
 
 
 
堆
 
Java程序在运行时建立的全部类实或数组都放在同一个堆中。而一个Java虚拟实例中只存在一个堆空间，所以全部线程都将共享这个堆。
 
Java对象中包含的基本数据由他所属的类及其全部超类声明的实例变量组成。只要有一个对象引用，虚拟机就必须可以快速的定位对象实例的数据。另外，它也必须能经过该对象引用访问相应的类数据（存储于方法区的类型信息）。所以在对象中一般会有一个指向方法区的指针。
 
程序计数器
 
       每一个运行中的Java程序，每个线程都有它本身的PC寄存器，也是该线程启动时建立的。PC寄存器的内容老是指向下一条将被执行指令的饿“地址”，这里的“地址”能够是一个本地指针，也能够是在方法区中相对应于该方法起始指令的偏移量。
 
Java栈
 
       Java栈以帧为单位保存线程的运行状态。虚拟机只会直接对Java栈执行两种操做：以帧为单位的压栈或出栈。
 
       和方法区和堆同样，Java栈和帧在内存中也没必要是连续的。帧能够分布在连续的栈里，也能够分布在堆里，或者二者兼有的。
 
       栈帧
 
       栈帧由三部分组成：局部变量、操做数栈和帧数据区。
 
       当虚拟机调用一个Java方法时，它从对应类的而类型信息中获得此方法的局部变量区和操做数栈的大小，并据此分配栈帧内存，而后压入Java栈中。
 
       局部变量：存放局部变量和方法参数
       操做数栈：线程的工做区，用来存放运算过程当中的临时数据
       帧数据区：保存支持常量解析、正常方法返回以及异常派发机制的数据

Java内存区域与内存溢出异常:http://raging-sweet.iteye.com/blog/1166888（压缩版本）

参考：http://www.cnblogs.com/Cratical/archive/2012/08/21/2649985.html

  1. 运行时数据区域：
  2. 包括 方法区，虚拟机栈，本地方法栈，堆 和程序计数器。
  4. 程序计数器：
  5. 是一块较小的内存空间，它的做用能够看做是当前线程所执行的字节码的行号指示器。
  6. 每个线程都有本身私有的程序计数器。
  7. 若是线程正在执行的是一个JAVA方法，该计数器记录的是正在执行的虚拟机字节码指令的地址，若是正在执行的是native方法，则计数器值为空（undefined）。此内存区域是惟一一个在JAVA虚拟机规范中没有规定任何OutOfMemoryError状况的区域。
  10. JAVA虚拟机栈：
  11. 也是线程私有的，生命周期和线程相同。每一个方法被执行的时候都会同时建立一个栈帧（stack frame)用于存储局部变量表、操做栈、动态连接、方法出口等信息。每一个方法被调用直至执行完成的过程，就对应一个栈帧在虚拟机栈中从入栈道出栈的过程。
  13. 这个JAVA虚拟机栈就是咱们常说的“栈”。局部变量表存放了元数据类型、引用类型
  14. 局部变量表所需的内存空间在编译期间完成分配，当进入一个方法时，这个方法须要在帧中分配多大的局部变量空间是彻底肯定的，在方法运行期间不会改变局部变量表的大小。
  16. 在JVM规范中，对这个区域规定了两种异常状况：
  18. 若是线程请求的栈深度大于JVM容许的深度，抛出StackOverflowError
  19. 若是虚拟机栈能够动态扩展（目前大部分JVM均可动态扩展），当扩展时没法申请到足够的内存时，会抛出OutOfMemoryError异常
  20. 本地方法栈：
  21. 与虚拟机栈做用相似，只不过前者是执行JAVA方法服务，而本地方法栈是为Native方法服务。
  22. HotSpot将本地方法栈和虚拟机栈合二为一。
  23. 和虚拟机栈同样会抛出来两种异常。
  25. JAVA堆：
  26. JAVA堆是被全部线程共享的一块内存区域，在JVM启动时建立。其做用就是存放对象实例。
  27. JVM规范规定：全部的对象实例及数组都要在堆上分配。
  28. JAVA堆也是垃圾回收管理的主要区域。
  29. 因为如今收集器基本采用分代收集算法，因此JAVA堆还能够细分为：新生代和老年代，再细分还有Eden空间、From Survivor空间、To Survivor空间。
  30. 根据JVM规范，JAVA堆能够处于物理上不连续的内存空间中，只要逻辑上是连续的便可，能够是固定大小的，也能够是可扩展的（用-Xmx和-Xms控制），若是堆中没有内存，也没法扩展，抛出OutOfMemoryError。
  33. 方法区：
  34. 也是全部线程共享的内存区域。它用于存放虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
  35. 在JVM规范中被描述为堆的一部分，但却又有一个non-heap的别名。
  37. 对于HOTSPOT虚拟机，方法区又被称为永久代(Permanent Generation）
  38. 这个区域同样不须要连续的内存，能够选择固定大小或者扩展，还能够选择不实现垃圾回收。确实这个区域的数据通常不参与回收，但这些数据并不必定就是永久存在了，常量池和对类型的卸载也能够成为回收的目标。
  39. 抛出OutOfMemoryError
  41. 运行时常量池（方法区的一部分）：
  42. 是方法区的一部分。
  43. 在编译期生成的各类字面量和符号引用，这部份内容将在类加载后存放到方法区的运行时常量池中。
  45. 这个区域并非只有编译时产生的常量，也有运行时产生的常量，好比String.intern()方法。
  46. 既然运行时常量池是方法区的一部分，天然会受到方法区内存的限制，当常量池没法再申请到内存时会抛出OutOfMemoryError异常。
  48. 直接内存：
  49. Direct Memory
  50. 在JDK1.4中引入了NIO,是一种基于通道与缓冲区的I/O方式，它可使用Native函数库直接分配堆外内存，而后经过一个存储在JAVA堆里面的DirectByteBuffer对象做为这块内存的引用进行操做。
  51. 本机直接内存的分配不会受到Java堆大小的限制，可是，既然是内存，则确定仍是会受到本机总内存（包括RAM及SWAP区或者分页文件）的大小及处理器寻址空间的限制。服务器管理员配置虚拟机参数时，通常会根据实际内存设置-Xmx等参数信息，但常常会忽略掉直接内存，使得各个内存区域的总和大于物理内存限制（包括物理上的和操做系统级的限制），从而致使动态扩展时出现OutOfMemoryError异常。
  54. Object obj = new Object();
  55. Object obj反映到JAVA栈的本地变量表中
  56. new Object()反映到JAVA堆中，长度不肯定，在JAVA堆中还必须包含能查找到此对象类型数据（如对象类型、父类、实现的接口、方法等）的地址信息，这些类型数据则存放在方法区中。
  58. 引用访问对象的方法主流的有两种：
  59. 使用句柄访问方式，JAVA堆中将会划分出一块内存来做为句柄池，引用对象存储的是对象的句柄地址，而句柄中包含着对象实例数据和类型数据各自的具体地址信息。
  60. 直接指针访问方式。引用对象中直接存储的就是对象地址。，在堆中的对象又有一个指针指向方法区的对象类型数据。
  61. 句柄访问方式最大的好处是在对象被移动时（垃圾回收常常会移动对象），只用改变句柄中的实例数据指针，而引用对象不用修改。
  62. 直接指针方式最大的好处是速度更快。HOTSPOT使用这种方式。
  64. 设置堆不可扩展，将-Xms和-Xmx参数设置同样便可。
  66. 栈溢出
  67. -Xoss参数设置本地方法栈大小（在HOTSPOT虚拟机中，因为本地方法栈和虚拟机栈是一块儿的，因此这个参数是无效的），-Xss参数设定栈大小。
  68. 栈溢出会抛出两种异常stackoverflow和outofmemory，前者表示线程请求的栈深度大于虚拟机所容许的最大深度，后者表示没法申请到足够的内存空间。
  70. 实验代表，单线程只会有stackoverflow,不会有outofmemory.但多线程会产生Outofmemory。
  72. 这是由于，OS分配给每一个进程的内存是有限制的，好比32位windows限制为2GB，栈内存的总量是由2GB减去堆内存（Xmx）,再减去方法区容量（MaxPermSize），由于程序计数器消耗内存很小，能够忽略不计。而栈内存又被多个线程所瓜分，这样在线程不少的状况下，内存就可能会耗尽。
  75. 运行时常量池溢出
  76. 经过String.intern()方法能够向运行时常量池增长内容，该方法会检测常量池中是否有某个字符串，若是有就返回池中的字符串，不然将该字符串加入常量池，再返回该常量池字符串的引用。
  78. 因为常量池分配在方法区中，能够经过-XX:PermSize和-XX:MaxPermSize来限制方法区大小。方法区溢出的标志就是OutOfMemoryError: PermGen Space.
  81. 方法区溢出
  82. 主要是因为动态生成了太多的类形成的，这种溢出的实际场景好比大量JSP或动态生成JSP文件的应用（JSP第一次运行时会须要编译成JAVA类）CGLIB等动态代理生成框架产生的动态类等
  84. 本机直接内存溢出
  85. DirectMemory容量能够由-XX:MaxDirectMemorySize指定，若是不指定，则默认与JAVA堆最大值（-Xmx)同样。实际上DirectByteBuffer并无直接申请分配内存，而是先计算，若是计算得知无足够内存可分配，就抛出异常。 
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程