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

时间 2019-11-10 标签深刻理解 jvm 内存区域分配

　　前言：这是一篇关于JVM内存区域的文章，由网上一些有关这方面的文章和《深刻理解Java虚拟机》整理而来，因此会有些类同的地方，也不能保证我本身写的比其余网上的和书本上的要好，也不可能会这样。写博客的目的是为了我的对这方面本身理解的分享与我的的积累，因此有写错的地方多多指教。html

　　看到深刻两字，相信不少的JAVA初学者都会直接忽略这样的文章，其实关于JVM内存区域的知识对于初学者来讲实际上是很重要的，了解Java内存分配的原理，这对于之后JAVA的学习会有更深入的理解，这是我我的的见解。java

　　先来看看JVM运行时候的内存区域bootstrap

　　大多数 JVM 将内存区域划分为 Method Area（Non-Heap）（方法区）,Heap（堆）,Program Counter Register（程序计数器）, VM Stack（虚拟机栈，也有翻译成JAVA 方法栈的）,Native Method Stack （本地方法栈），其中Method Area和Heap是线程共享的，VM Stack，Native Method Stack 和Program Counter Register是非线程共享的。为何分为线程共享和非线程共享的呢?请继续往下看。数组

　　首先咱们熟悉一下一个通常性的 Java 程序的工做过程。一个 Java 源程序文件，会被编译为字节码文件（以 class 为扩展名），每一个java程序都须要运行在本身的JVM上，而后告知 JVM 程序的运行入口，再被 JVM 经过字节码解释器加载运行。那么程序开始运行后，都是如何涉及到各内存区域的呢？学习

　　归纳地说来，JVM初始运行的时候都会分配好Method Area（方法区）和Heap（堆），而JVM 每遇到一个线程，就为其分配一个Program Counter Register（程序计数器）, VM Stack（虚拟机栈）和Native Method Stack （本地方法栈），当线程终止时，三者（虚拟机栈，本地方法栈和程序计数器）所占用的内存空间也会被释放掉。这也是为何我把内存区域分为线程共享和非线程共享的缘由，非线程共享的那三个区域的生命周期与所属线程相同，而线程共享的区域与JAVA程序运行的生命周期相同，因此这也是系统垃圾回收的场所只发生在线程共享的区域（实际上对大部分虚拟机来讲知发生在Heap上）的缘由。this

1.　　程序计数器spa

　　程序计数器是一块较小的内存区域，做用能够看作是当前线程执行的字节码的位置指示器。分支、循环、跳转、异常处理和线程恢复等基础功能都须要依赖这个计算器来完成，很少说。操作系统

2.VM Strack.net

　　先来了解下JAVA指令的构成：线程

　　JAVA指令由 操做码 （方法自己）和 操做数 （方法内部变量）组成。　　　

　　　　1）方法自己是指令的操做码部分，保存在Stack中；

　　　　2）方法内部变量（局部变量）做为指令的操做数部分，跟在指令的操做码以后，保存在Stack中（其实是简单类型（int,byte,short 等）保存在Stack中，对象类型在Stack中保存地址，在Heap 中保存值）；

　　虚拟机栈也叫栈内存，是在线程建立时建立，它的生命期是跟随线程的生命期，线程结束栈内存也就释放，对于栈来讲不存在垃圾回收问题，只要线程一结束，该栈就 Over，因此不存在垃圾回收。也有一些资料翻译成JAVA方法栈，大概是由于它所描述的是java方法执行的内存模型，每一个方法执行的同时建立帧栈（Strack Frame）用于存储局部变量表（包含了对应的方法参数和局部变量），操做栈（Operand Stack，记录出栈、入栈的操做），动态连接、方法出口等信息，每一个方法被调用直到执行完毕的过程，对应这帧栈在虚拟机栈的入栈和出栈的过程。

　　局部变量表存放了编译期可知的各类基本数据类型（boolean、byte、char、short、int、float、long、double）、对象的引用（reference类型，不等同于对象自己，根据不一样的虚拟机实现，多是一个指向对象起始地址的引用指针，也多是一个表明对象的句柄或者其余与对象相关的位置）和 returnAdress类型（指向下一条字节码指令的地址）。局部变量表所需的内存空间在编译期间完成分配，在方法在运行以前，该局部变量表所须要的内存空间是固定的，运行期间也不会改变。

　　栈帧是一个内存区块，是一个数据集，是一个有关方法(Method)和运行期数据的数据集，当一个方法 A 被调用时就产生了一个栈帧 F1，并被压入到栈中，A 方法又调用了 B 方法，因而产生栈帧 F2 也被压入栈，执行完毕后，先弹出 F2栈帧，再弹出 F1 栈帧，遵循“先进后出”原则。光说比较枯燥，咱们看一个图来理解一下 Java栈，以下图所示：

3.Heap

　　Heap（堆）是JVM的内存数据区。Heap 的管理很复杂，是被全部线程共享的内存区域，在JVM启动时候建立，专门用来保存对象的实例。在Heap 中分配必定的内存来保存对象实例，实际上也只是保存对象实例的属性值，属性的类型和对象自己的类型标记等，并不保存对象的方法（以帧栈的形式保存在Stack中）,在Heap 中分配必定的内存保存对象实例。而对象实例在Heap 中分配好之后，须要在Stack中保存一个4字节的Heap 内存地址，用来定位该对象实例在Heap 中的位置，便于找到该对象实例，是垃圾回收的主要场所。java堆处于物理不连续的内存空间中，只要逻辑上连续便可。

4.Method Area

　　Object Class Data(加载类的类定义数据) 是存储在方法区的。除此以外，常量、静态变量、JIT(即时编译器)编译后的代码也都在方法区。正由于方法区所存储的数据与堆有一种类比关系，因此它还被称为 Non-Heap。方法区也能够是内存不连续的区域组成的，而且可设置为固定大小，也能够设置为可扩展的，这点与堆同样。

　　垃圾回收在这个区域会比较少出现，这个区域内存回收的目的主要针对常量池的回收和类的卸载。

5.运行时常量池（Runtime Constant Pool）

　　方法区内部有一个很是重要的区域，叫作运行时常量池（Runtime Constant Pool，简称 RCP）。在字节码文件（Class文件）中，除了有类的版本、字段、方法、接口等先关信息描述外，还有常量池（Constant Pool Table）信息，用于存储编译器产生的字面量和符号引用。这部份内容在类被加载后，都会存储到方法区中的RCP。值得注意的是，运行时产生的新常量也能够被放入常量池中，好比 String 类中的 intern() 方法产生的常量。

　　常量池就是这个类型用到的常量的一个有序集合。包括直接常量(基本类型，String)和对其余类型、方法、字段的符号引用.例如：

◆类和接口的全限定名；

◆字段的名称和描述符；

◆方法和名称和描述符。

　　池中的数据和数组同样经过索引访问。因为常量池包含了一个类型全部的对其余类型、方法、字段的符号引用，因此常量池在Java的动态连接中起了核心做用.

　　颇有用且重要关于常量池的扩展：Java常量池详解 http://www.cnblogs.com/DreamSea/archive/2011/11/20/2256396.html

6.Native Method Stack

　　与VM Strack类似，VM Strack为JVM提供执行JAVA方法的服务，Native Method Stack则为JVM提供使用native 方法的服务。

7.直接内存区

　　直接内存区并非 JVM 管理的内存区域的一部分，而是其以外的。该区域也会在 Java 开发中使用到，而且存在致使内存溢出的隐患。若是你对 NIO 有所了解，可能会知道 NIO 是可使用 Native Methods 来使用直接内存区的。

小结：

　　在此，你对JVM的内存区域有了必定的理解，JVM内存区域能够分为线程共享和非线程共享两部分，线程共享的有堆和方法区，非线程共享的有虚拟机栈，本地方法栈和程序计数器。

8.JVM运行原理例子

以上都是纯理论，咱们举个例子来讲明 JVM 的运行原理，咱们来写一个简单的类，代码以下：

 1 public class JVMShowcase {  
 2 //静态类常量,  
 3 public final static String ClASS_CONST = "I'm a Const";  
 4 //私有实例变量  
 5 private int instanceVar=15;  
 6 public static void main(String[] args) {  
 7 //调用静态方法  
 8 runStaticMethod();  
 9 //调用非静态方法  
10 JVMShowcase showcase=new JVMShowcase();  
11 showcase.runNonStaticMethod(100);  
12 }  
13 //常规静态方法  
14 public static String runStaticMethod(){  
15 return ClASS_CONST;  
16 }  
17 //非静态方法  
18 public int runNonStaticMethod(int parameter){  
19 int methodVar=this.instanceVar * parameter;  
20 return methodVar;  
21 }  
22 }

这个类没有任何意义，不用猜想这个类是作什么用，只是写一个比较典型的类，而后咱们来看

看 JVM 是如何运行的，也就是输入 java JVMShow 后，咱们来看 JVM 是如何处理的：

第 1 步 、 向操做系统申请空闲内存。JVM 对操做系统说“给我 64M（随便模拟数据，并非真实数据）空闲内存”，因而，JVM 向操做系统申请空闲内存做系统就查找本身的内存分配表，找了段 64M 的内存写上“Java 占用”标签，而后把内存段的起始地址和终止地址给 JVM，JVM 准备加载类文件。

第 2 步， 分配内存内存。JVM 分配内存。JVM 得到到 64M 内存，就开始得瑟了，首先给 heap 分个内存，而后给栈内存也分配好。

第 3 步， 文件检查和分析class 文件。若发现有错误即返回错误。

第 4 步， 加载类。加载类。因为没有指定加载器，JVM 默认使用 bootstrap 加载器，就把 rt.jar 下的全部类都加载到了堆类存的Method Area，JVMShow 也被加载到内存中。咱们来看看Method Area区域，以下图：（ 这时候包含了 main 方法和 runStaticMethod方法的符号引用，由于它们都是静态方法，在类加载的时候就会加载）

Heap 是空，Stack 是空，由于尚未对象的新建和线程被执行。

第 5 步、 执行方法。执行 main 方法。执行启动一个线程，开始执行 main 方法，在 main 执行完毕前，方法区以下图所示：

（ public final static String ClASS_CONST = "I'm a Const"; ）

在 Method Area 加入了 CLASS_CONST 常量，它是在第一次被访问时产生的（runStaticMethod方法内部）。

堆内存中有两个对象 object 和 showcase 对象，以下图所示：（执行了JVMShowcase showcase=new JVMShowcase(); ）

为何会有 Object 对象呢？是由于它是 JVMShowcase 的父类， JVM 是先初始化父类，而后再初始化子类，甭管有多少个父类都初始化。

在栈内存中有三个栈帧，以下图所示：

于此同时，还建立了一个程序计数器指向下一条要执行的语句。

第 6 步，释放内存。释放内存。运行结束，JVM 向操做系统发送消息，说“内存用完了，我还给你”，运行结束。

--------------------------------------------------------------------------------------------

如今来看JVM内存是如何分配的，该部分转载来自 http://blog.csdn.net/shimiso/article/details/8595564

预备知识：

1.一个Java文件，只要有main入口方法，咱们就认为这是一个Java程序，能够单独编译运行。

2.不管是普通类型的变量仍是引用类型的变量(俗称实例)，均可以做为局部变量，他们均可以出如今栈中。只不过普通类型的变量在栈中直接保存它所对应的值，而引用类型的变量保存的是一个指向堆区的指针，经过这个指针，就能够找到这个实例在堆区对应的对象。所以，普通类型变量只在栈区占用一块内存，而引用类型变量要在栈区和堆区各占一块内存。

示例：（如下全部实例中，是根据须要对于栈内存中的帧栈简化成了只有局部变量表，实际上由上面对帧栈的介绍知道不只仅只有这些信息，同理堆内存也同样）

1.JVM自动寻找main方法，执行第一句代码，建立一个Test类的实例，在栈中分配一块内存，存放一个指向堆区对象的指针110925。

2.建立一个int型的变量date，因为是基本类型，直接在栈中存放date对应的值9。

3.建立两个BirthDate类的实例d一、d2，在栈中分别存放了对应的指针指向各自的对象。他们在实例化时调用了有参数的构造方法，所以对象中有自定义初始值。

调用test对象的change1方法，而且以date为参数。JVM读到这段代码时，检测到i是局部变量，所以会把i放在栈中，而且把date的值赋给i。

把1234赋给i。很简单的一步。

change1方法执行完毕，当即释放局部变量i所占用的栈空间。

调用test对象的change2方法，以实例d1为参数。JVM检测到change2方法中的b参数为局部变量，当即加入到栈中，因为是引用类型的变量，因此b中保存的是d1中的指针，此时b和d1指向同一个堆中的对象。在b和d1之间传递是指针。

change2方法中又实例化了一个BirthDate对象，而且赋给b。在内部执行过程是：在堆区new了一个对象，而且把该对象的指针保存在栈中的b对应空间，此时实例b再也不指向实例d1所指向的对象，可是实例d1所指向的对象并没有变化，这样没法对d1形成任何影响。

change2方法执行完毕，当即释放局部引用变量b所占的栈空间，注意只是释放了栈空间，堆空间要等待自动回收。

调用test实例的change3方法，以实例d2为参数。同理，JVM会在栈中为局部引用变量b分配空间，而且把d2中的指针存放在b中，此时d2和b指向同一个对象。再调用实例b的setDay方法，其实就是调用d2指向的对象的setDay方法。

调用实例b的setDay方法会影响d2，由于两者指向的是同一个对象。

change3方法执行完毕，当即释放局部引用变量b。

以上就是Java程序运行时内存分配的大体状况。其实也没什么，掌握了思想就很简单了。无非就是两种类型的变量：基本类型和引用类型。两者做为局部变量，都放在栈中，基本类型直接在栈中保存值，引用类型只保存一个指向堆区的指针，真正的对象在堆里。做为参数时基本类型就直接传值，引用类型传指针。

小结：

1.分清什么是实例什么是对象。Class a= new Class();此时a叫实例，而不能说a是对象。实例在栈中，对象在堆中，操做实例其实是经过实例的指针间接操做对象。多个实例能够指向同一个对象。

2.栈中的数据和堆中的数据销毁并非同步的。方法一旦结束，栈中的局部变量当即销毁，可是堆中对象不必定销毁。由于可能有其余变量也指向了这个对象，直到栈中没有变量指向堆中的对象时，它才销毁，并且还不是立刻销毁，要等垃圾回收扫描时才能够被销毁。

3.以上的栈、堆、代码段、数据段等等都是相对于应用程序而言的。每个应用程序都对应惟一的一个JVM实例，每个JVM实例都有本身的内存区域，互不影响。而且这些内存区域是全部线程共享的。这里提到的栈和堆都是总体上的概念，这些堆栈还能够细分。

4.类的成员变量在不一样对象中各不相同，都有本身的存储空间(成员变量在堆中的对象中)。而类的方法倒是该类的全部对象共享的，只有一套，对象使用方法的时候方法才被压入栈，方法不使用则不占用内存。