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

时间：2022-12-27 00:10:27

JVM的内存形式：

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

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

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

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

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

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


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

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

　　概述：

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

一个对象的“所有权”，又担负着每一个对象生命开始到终结的维护责任。

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

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

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

 

　　运行时数据区域

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

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

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

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

 

　　程序计数器　　　　　

　　程序计数器（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虚拟机规范中，对这个区域规定了两种异常状况：如果线程请求的栈深度大于虚拟机所允许的深度，将抛出

*Error异常；如果虚拟机栈可以动态扩展（当前大部分的Java虚拟机都可动态扩展，只不过Java虚拟机规范中也允许固定长度的

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

 

　　本地方法栈

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

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

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

虚拟机栈一样，本地方法栈区域也会抛出*Error和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 JVM的内存区域（运行时数据区域）

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

图所示：

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

　　这两种对象的访问方式各有优势，使用句柄访问方式的最大好处就是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

[plain] view plain copy print?java JVM的内存区域（运行时数据区域）java JVM的内存区域（运行时数据区域）
  1. 当Java虚拟机运行时，它需要内存来存取很多东西。例如，字节码，从已经装载的class文件中得到的其他信息，程序创建的对象，传递给方法的参数，返回值，局部变量，已经运算的中间结果等。Java虚拟机把这些数据都组织到几个“运行时数据区”，以便于管理，主要包括方法区、堆、Java栈、PC寄存器、本地方法栈。  
  2.    
  3.    
  4. 方法区  
  5.    
  6.       在Java虚拟机中，关于被装载的类型的信息存储在一个逻辑上被称为方法区的内存中。当虚拟机装载某个类型时，它使用类装载器定位相应的class文件，然后读入这个class文件--------一个线性二进制数据流--------然后把它传输到虚拟机中。紧接着虚拟机提取其中的类型信息，并将这些信息存储到方法区。该类型中的类（静态）变量同样也存储在方法区中。  
  7.    
  8.        由于所有线程都共享方法区，因此它们对方法区数据的访问必须被设计是线程安全的。比如，假设同时两个线程都企图访问一个名为Lava的类，而这个类还没有内装载入虚拟机，那么，这时应该只有一个线程去装载它，而另一个线程则只能等待。  
  9.    
  10.        对每个装载的类型，虚拟机都会在方法区中存储一下类型信息：  
  11.    
  12. l  这个类型的全限定名  
  13. l  这个类型的直接超类的全限定名（除了Object）  
  14. l  这个类型的是类类型还是接口类型  
  15. l  这个类型的访问修饰符  
  16. l  任何直接超接口的全限定名的有序列表  
  17. 除了上面的基本信息以外，虚拟机还得为每个被装载的类型存储以下信息：  
  18.    
  19. l  该类型的常量池  
  20. l  字段信息  
  21. l  方法信息  
  22. l  除了常量以外的所有类变量  
  23. l  一个到ClassLoader的引用  
  24. l  一个到Class类的引用  
  25.    
  26.         
  27. 指向ClassLoader的引用  
  28.    
  29.        每个类型被装载的时候，虚拟机必须跟踪它是由启动类装载器还是由用户自定义类装载器装载的。如果是用户自定义类装载器装载的，那么虚拟机必须在类型信息中存储对该类型装载器的引用。这是作为方法表中的类型数据的一部分保存的。  
  30.    
  31.        虚拟机会在动态连接期间使用这个信息。当某个类型引用另一个类型的时候，虚拟机会请求装载发起引用的类装载器来装载被引用的类型。这个动态连接的过程，对于虚拟机分离命名空间的方式也是至关重要的。为了能够正确执行动态连接以及维护多个命名空间，虚拟机需要在方法表中得知每个类都是哪个类装载器装载的。  
  32.    
  33.    
  34.    
  35. 指向Class的引用  
  36.    
  37. 对于每个被装载的类型（不管是类还是接口），虚拟机都会相应地为它在堆上创建一个java.lang.Class类的实例，而且虚拟机还必须以某种方式把这个实例和存储在方法区中的类型数据关联起来。  
  38.    
  39.        在程序中，可以使用指向Class对象的引用。Class类中的两个方法可以得到任何已装载的类的Class实例的引用。分别是Class.forName(“”)以及Class.getClass()。  
  40.    
  41.        给出一个Class对象的引用，就可以通过Class类中的定义的方法来找出这个类型的相关信息。如果查看这些方法会很快意思到，Class类使得运行程序可以访问方法区中保存的信息。下面的是Class类中声明的方法：  
  42.    
  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对象的引用  
  48.    
  49.    
  50.    
  51. 堆  
  52.    
  53. Java程序在运行时创建的所有类实或数组都放在同一个堆中。而一个Java虚拟实例中只存在一个堆空间，因此所有线程都将共享这个堆。  
  54.    
  55. Java对象中包含的基本数据由他所属的类及其所有超类声明的实例变量组成。只要有一个对象引用，虚拟机就必须能够快速的定位对象实例的数据。另外，它也必须能通过该对象引用访问相应的类数据（存储于方法区的类型信息）。因此在对象中通常会有一个指向方法区的指针。  
  56.    
  57. 程序计数器  
  58.    
  59.        每个运行中的Java程序，每一个线程都有它自己的PC寄存器，也是该线程启动时创建的。PC寄存器的内容总是指向下一条将被执行指令的饿“地址”，这里的“地址”可以是一个本地指针，也可以是在方法区中相对应于该方法起始指令的偏移量。  
  60.    
  61. Java栈  
  62.    
  63.        Java栈以帧为单位保存线程的运行状态。虚拟机只会直接对Java栈执行两种操作：以帧为单位的压栈或出栈。  
  64.    
  65.        和方法区和堆一样，Java栈和帧在内存中也不必是连续的。帧可以分布在连续的栈里，也可以分布在堆里，或者两者兼有的。  
  66.    
  67.        栈帧  
  68.    
  69.        栈帧由三部分组成：局部变量、操作数栈和帧数据区。  
  70.    
  71.        当虚拟机调用一个Java方法时，它从对应类的而类型信息中得到此方法的局部变量区和操作数栈的大小，并据此分配栈帧内存，然后压入Java栈中。  
  72.    
  73.        局部变量：存放局部变量和方法参数  
  74.        操作数栈：线程的工作区，用来存放运算过程中的临时数据  
  75.        帧数据区：保存支持常量解析、正常方法返回以及异常派发机制的数据  

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

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

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

相关文章