JVM的学习

1. 类加载器子系统

Java的动态类加载功能是由类加载器子系统处理。当它在运行时（不是编译时）首次引用一个类时，它加载、链接并初始化该类文件。

1.1 加载

类由此组件加载。启动类加载器 (BootStrap class Loader)、扩展类加载器(Extension class Loader)和应用程序类加载器(Application class Loader) 这三种类加载器帮助完成类的加载。

1. 启动类加载器 – 负责从启动类路径中加载类，无非就是rt.jar。这个加载器会被赋予最高优先级。

2. 扩展类加载器 – 负责加载ext 目录(jre\lib)内的类.

3. 应用程序类加载器 – 负责加载应用程序级别类路径，涉及到路径的环境变量等etc.

上述的类加载器会遵循委托层次算法（Delegation Hierarchy Algorithm）加载类文件。

1.2 链接

1. 校验 – 字节码校验器会校验生成的字节码是否正确，如果校验失败，我们会得到校验错误。

2. 准备 – 分配内存并初始化默认值给所有的静态变量。

3. 解析 – 所有符号内存引用被方法区(Method Area)的原始引用所替代。

1.3 初始化

这是类加载的最后阶段，这里所有的静态变量会被赋初始值, 并且静态块将被执行。

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

The 运行时数据区域被划分为5个主要组件：

2.1 方法区（Method Area）

所有类级别数据将被存储在这里，包括静态变量。每个JVM只有一个方法区，它是一个共享的资源。

2.2 堆区（Heap Area）

所有的对象和它们相应的实例变量以及数组将被存储在这里。每个JVM同样只有一个堆区。由于方法区和堆区的内存由多个线程共享，所以存储的数据不是线程安全的。

2.3 栈区（Stack Area）

对每个线程会单独创建一个运行时栈。对每个函数呼叫会在栈内存生成一个栈帧(Stack Frame)。所有的局部变量将在栈内存中创建。栈区是线程安全的，因为它不是一个共享资源。栈帧被分为三个子实体：

a 局部变量数组 – 包含多少个与方法相关的局部变量并且相应的值将被存储在这里。

b 操作数栈 – 如果需要执行任何中间操作，操作数栈作为运行时工作区去执行指令。

c 帧数据 – 方法的所有符号都保存在这里。在任意异常的情况下，catch块的信息将会被保存在帧数据里面。
2.4 PC寄存器

每个线程都有一个单独的PC寄存器来保存当前执行指令的地址，一旦该指令被执行，pc寄存器会被更新至下条指令的地址。

2.5 本地方法栈

本地方法栈保存本地方法信息。对每一个线程，将创建一个单独的本地方法栈。

3. 执行引擎

分配给运行时数据区的字节码将由执行引擎执行。执行引擎读取字节码并逐段执行。

3.1 解释器:

解释器能快速的解释字节码，但执行却很慢。 解释器的缺点就是,当一个方法被调用多次，每次都需要重新解释。

编译器

JIT编译器消除了解释器的缺点。执行引擎利用解释器转换字节码，但如果是重复的代码则使用JIT编译器将全部字节码编译成本机代码。本机代码将直接用于重复的方法调用，这提高了系统的性能。

a. 中间代码生成器 – 生成中间代码

b. 代码优化器 – 负责优化上面生成的中间代码

c. 目标代码生成器 – 负责生成机器代码或本机代码

d. 探测器(Profiler) – 一个特殊的组件，负责寻找被多次调用的方法。

3.3 垃圾回收器:

收集并删除未引用的对象。可以通过调用"System.gc()"来触发垃圾回收，但并不保证会确实进行垃圾回收。JVM的垃圾回收只收集哪些由new关键字创建的对象。所以，如果不是用new创建的对象，你可以使用finalize函数来执行清理。

Java本地接口 (JNI): JNI 会与本地方法库进行交互并提供执行引擎所需的本地库。

本地方法库:它是一个执行引擎所需的本地库的集合。

垃圾回收策略————如何判断对象已死？

需要垃圾回收某一个对象时，需要判断这个对象是否可以回收，怎么判断一般有两种算法：
1 引用计数算法（Reference Counting）
给对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加1；当引用失效时，计数器值
就减1；任何时刻计数器为0的对象就是不可能再被使用的。 引用计数算法的实现简单，判定效率也很
高，在大部分情况下它都是一个不错的算法。但是它很难解决对象之间相互循环引用的问题。
Python、ActionScript等语言都是基于引用计数法。
2 可达性分析算法
通过一系列的称为“GC Roots”的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为
GC Roots引用链（Reference Chain），当一个对象到GC Roots没有任何引用链相连（用图论的话来
说，就是从GC Roots到这个对象不可达）时，则证明此对象是不可用的。如下图，object5和object6虽
然相互引用，但是由于他们到GC Roots都不可达，因此会被判定为可回收的对象。 Java、C#等语言都
是使用可达性分析算法进行垃圾回收。

垃圾回收算法

1 标记-清除算法（Mark-Sweep算法）
最基础的收集算法，老年代收集算法。
如同它的名字一样，算法分为“标记”和“清除”两个阶段：首先标记出所有需要回收的对象，在标记
完成后统一回收所有被标记的对象。
之所以说它是最基础的收集算法，是因为后续的收集算法都是基于这种思路并对其不足进行改进而
得到的。
它的主要不足有两个：

1. 效率问题，标记和清除两个过程的效率都不高。
2. 空间问题，标记清除之后会产生大量不连续的内存碎片，空间碎片太多可能会导致以后在程
   序运行过程中需要分配较大对象时，无法找到足够的连续内存而不得不提前触发另一次垃圾
   收集动作。
   2复制算法（Copying算法）
   新生代的收集算法
   将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。当这一块的内存用完了，就将
   还存活着的对象复制到另外一块上面，然后再把已使用过的内存空间一次清理掉。这样使得每次都
   是对整个半区进行内存回收，内存分配时也就不用考虑内存碎片等复杂情况，只要移动堆顶指针，
   按顺序分配内存即可，实现简单，运行高效。
   只是这种算法的代价是将内存缩小为了原来的一半，未免太高了一点。
   3 标记-整理算法（Mark-Compact算法）
   老年代收集算法
   标记过程仍与"标记-清除"过程一致，但后续步骤不是直接对可回收对象进行清理，而是让所有存
   活对象都向一端移动，然后直接清理掉端边界以外的内存。7.4 分代收集算法
   当前JVM垃圾收集都采用的是"分代收集(Generational Collection)"算法，这个算法并没有新思
   想，只是根据对象存活周期的不同将内存划分为几块。
   一般是把Java堆分为新生代和老年代。
   新生代中98%的对象都是"朝生夕死"的，所以并不需要按照复制算法所要求1 : 1的比例来划分内存
   空间，而是将内存（新生代内存）分为一块较大的Eden（伊甸园）空间和两块较小的
   Survivor（幸存者）空间，每次使用Eden和其中一块Survivor（两个Survivor区域一个称为From
   区，另一个称为To区域）。HotSpot默认Eden与Survivor的大小比例是8 : 1，也就是说Eden :
   Survivor From : Survivor To = 8 : 1 : 1。所以每次新生代可用内存空间为整个新生代容量的90%，
   只有10%的内存会被”浪费“。
   在新生代中，每次垃圾回收都有大批对象死去，只有少量存活，因此我们采用复制算法；而老年代
   中对象存活率高、没有额外空间对它进行分配担保，就必须采用"标记-清理"或者"标记-整理"算
   法。