JVM小结

JVM的运行流程

程序在执行之前先要把 java 代码转换成字节码（ class 文件）， JVM 首先需要把字节码通过一定的方式 类加载器（ ClassLoader ） 把文件加载到内存中 运行时数据区（ Runtime Data Area ） ，而字节码文件是 JVM 的一套指令集规范，并不能直接交个底层操作系统去执行，因此需要特定的命令解析器 执 行引擎（ Execution Engine ） 将字节码翻译成底层系统指令再交由 CPU 去执行，而这个过程中需要调用其他语言的接口 本地库接口（ Native Interface ） 来实现整个程序的功能，这就是这 4 个主要组成部分的职责与功能。

总结来看， JVM 主要通过分为以下 4 个部分，来执行 Java 程序的，它们分别是：

1. 类加载器（ ClassLoader ）

2. 运行时数据区（ Runtime Data Area ）

3. 执行引擎（ Execution Engine ）

4. 本地库接口（ Native Interface ）

下面分别介绍各个部分

JVM运行时数据区

JVM 运行时数据区域也叫内存布局，但需要注意的是它和 Java 内存模型（ (Java Memory Model ，简称JMM）完全不同，属于完全不同的两个概念，它由以下 5 大部分组成：

堆（线程共享）

堆的作用：程序中创建的所有对象都在保存在堆中。

堆里面分为两个区域：新生代和老生代，新生代放新建的对象，当经过一定 GC 次数之后还存活的对象会放入老生代。新生代还有 3 个区域：一个 Endn + 两个 Survivor （ S0/S1 ）。

垃圾回收的时候会将 Endn 中存活的对象放到一个未使用的 Survivor 中，并把当前的 Endn 和正在使用的 Survivor 清楚掉。

java虚拟机栈（线程私有）

Java 虚拟机栈的作用： Java 虚拟机栈的生命周期和线程相同， Java 虚拟机栈描述的是 Java 方法执行的内存模型：每个方法在执行的同时都会创建一个栈帧（Stack Frame ）用于存储局部变量表、操作数栈、动态链接、方法出口等信息。咱们常说的堆内存、栈内存中，栈内存指的就是虚拟机栈。

1. 局部变量表： 存放了编译器可知的各种基本数据类型 (8 大基本数据类型 ) 、对象引用。局部变量表所需的内存空间在编译期间完成分配，当进入一个方法时，这个方法需要在帧中分配多大的局部变量空间是完全确定的，在执行期间不会改变局部变量表大小。简单来说就是存放方法参数和局部变量。

2. 操作栈：每个方法会生成一个先进后出的操作栈。

3. 动态链接：指向运行时常量池的方法引用。

4. 方法返回地址： PC 寄存器的地址。

本地方法栈（线程私有）

本地方法栈和虚拟机栈类似，只不过 Java 虚拟机栈是给 JVM 使用的，而本地方法栈是给本地方法使用的。

程序计数器（线程私有）

程序计数器的作用：用来记录当前线程执行的行号的。

程序计数器是一块比较小的内存空间，可以看做是当前线程所执行的字节码的行号指示器。

如果当前线程正在执行的是一个 Java 方法，这个计数器记录的是正在执行的虚拟机字节码指令的地址；如果正在执行的是一个Native 方法，这个计数器值为空。

方法区（线程共享）

方法区的作用：用来存储被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据的。

运行时常量池

运行时常量池是方法区的一部分，存放字面量与符号引用。

JVM类加载的过程

类加载的过程

1.加载

2.验证

3.准备

4.解析

5.初始化

1）加载阶段

在加载阶段，要完成三件事情：

a. 通过一个类的全限定名来获取定义此类的二进制字节流。

b. 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。

c.在内存中生成一个代表这个类的 java.lang.Class 对象，作为方法区这个类的各种数据的访问入口。

2）验证阶段

验证是连接阶段的第一步，这一阶段的目的是确保 Class 文件的字节 流中包含的信息符合《 Java 虚拟机规范》的全部约束要求，保证这些信 息被当作代码运行后不会危害虚拟机自身的安全。

验证选项：

文件格式验证

字节码验证

符号引用验证 ...

3）准备阶段

准备阶段是正式为类中定义的变量（即静态变量，被 static 修饰的变量）分配内存并设置类变量初始值的阶段。

4）解析阶段

解析阶段是 Java 虚拟机将常量池内的符号引用替换为直接引用的过程，也就是初始化常量的过程。

5）初始化

初始化阶段， Java 虚拟机真正开始执行类中编写的 Java 程序代码，将主导权移交给应用程序。初始化阶段就是执行类构造器方法的过程。

双亲委派模型

如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最 终都应该传送到最顶层的启动类加载器中，只有当父加载器反馈自己无 法完成这个加载请求（它的搜索范围中没有找到所需的类）时，子加载器才会尝试自己去完成加载。

双亲委派模型的优点

1. 避免重复加载类：比如 A 类和 B 类都有一个父类 C 类，那么当 A 启动时就会将 C 类加载起来，那么在 B 类进行加载时就不需要在重复加载 C 类了。

2. 安全性：使用双亲委派模型也可以保证了 Java 的核心 API 不被篡改，如果没有使用双亲委派模

型，而是每个类加载器加载自己的话就会出现一些问题，比如我们编写一个称为 java.lang.Object

类的话，那么程序运行的时候，系统就会出现多个不同的 Object 类，而有些 Object 类又是用户

自己提供的因此安全性就不能得到保证了。

垃圾回收相关

Java 堆中存放着几乎所有的对象实例，垃圾回收器在对堆进行垃圾回收前，首先要判断这些对象哪些还存活，哪些已经" 死去 " 。判断对象是否已 " 死 " 有如下几种算法

死亡对象的判断方法

a）引用计数法

引用计数描述的算法为 :

给对象增加一个引用计数器，每当有一个地方引用它时，计数器就 +1 ；当引用失效时，计数器就 -1 ；任何时刻计数器为0 的对象就是不能再被使用的，即对象已 " 死 " 。

引用计数法实现简单，判定效率也比较高，在大部分情况下都是一个不错的算法。比如 Python 语言就采用引用计数法进行内存管理。

但是，在主流的 JVM 中没有选用引用计数法来管理内存，最主要的原因就是引用计数法无法解决对象的 循环引用问题

b）可达性分析算法

在上面我们讲了， Java 并不采用引用计数法来判断对象是否已 " 死 " ，而采用 " 可达性分析 " 来判断对象是否存活( 同样采用此法的还有 C# 、 Lisp- 最早的一门采用动态内存分配的语言 ) 。

此算法的核心思想为 : 通过一系列称为 "GC Roots" 的对象作为起始点，从这些节点开始向下搜索，搜索走过的路径称之为" 引用链 " ，当一个对象到 GC Roots 没有任何的引用链相连时 ( 从 GC Roots 到这个对象不可达) 时，证明此对象是不可用的。

在 Java 语言中，可作为 GC Roots 的对象包含下面几种 :

1. 虚拟机栈 ( 栈帧中的本地变量表 ) 中引用的对象；

2. 方法区中类静态属性引用的对象；

3. 方法区中常量引用的对象；

4. 本地方法栈中 JNI(Native 方法 ) 引用的对象。

垃圾回收算法

a）标记清除算法

" 标记 - 清除 " 算法是最基础的收集算法。算法分为 " 标记 " 和 " 清除 " 两个阶段 : 首先标记出所有需要回收的对象，在标记完成后统一回收所有被标记的对象( 标记过程见 3.1.2 章节 ) 。后续的收集算法都是基于这种思路并对其不足加以改进而已。

" 标记 - 清除 " 算法的不足主要有两个 :

1. 效率问题 : 标记和清除这两个过程的效率都不高

2. 空间问题 : 标记清除后会产生大量不连续的内存碎片，空间碎片太多可能会导致以后在程序运行中需要分配较大对象时，无法找到足够连续内存而不得不提前触发另一次垃圾收集。

b）复制算法

" 复制 " 算法是为了解决 " 标记 - 清理 " 的效率问题。它将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。当这块内存需要进行垃圾回收时，会将此区域还存活着的对象复制到另一块上面，然后再把已经使用过的内存区域一次清理掉。这样做的好处是每次都是对整个半区进行内存回收，内存分配时也就不需要考虑内存碎片等复杂情况，只需要移动堆顶指针，按顺序分配即可。此算法实现简单，运行高效。

c）标记整理算法

复制收集算法在对象存活率较高时会进行比较多的复制操作，效率会变低。因此在老年代一般不能使用复制算法。

针对老年代的特点，提出了一种称之为 " 标记 - 整理算法 " 。标记过程仍与 " 标记 - 清除 " 过程一致，但后续步骤不是直接对可回收对象进行清理，而是让所有存活对象都向一端移动，然后直接清理掉端边界以外的内存。

d）分代算法

分代算法和上面讲的 3 种算法不同，分代算法是通过区域划分，实现不同区域和不同的垃圾回收策略，从而实现更好的垃圾回收。这就好比中国的一国两制方针一样，对于不同的情况和地域设置更符合当地的规则，从而实现更好的管理，这就时分代算法的设计思想。

当前 JVM 垃圾收集都采用的是 " 分代收集 (Generational Collection)" 算法，这个算法并没有新思想，只是根据对象存活周期的不同将内存划分为几块。一般是把Java 堆分为新生代和老年代。 在新生代中，每 次垃圾回收都有大批对象死去，只有少量存活，因此我们采用复制算法；而老年代中对象存活率高、没 有额外空间对它进行分配担保，就必须采用 " 标记 - 清理 " 或者 " 标记 - 整理 " 算法 。

哪些对象会进入新生代？哪些对象会进入老年代？

新生代：一般创建的对象都会进入新生代；

老年代：大对象和经历了 N 次（一般情况默认是 15 次）垃圾回收依然存活下来的对象会从新生代

移动到老年代。