JVM

1. ClassLoader 类加载器
   1. 负责加载字节码文件即 class 文件
2. Runtime Data Area 运行时数据区，内存分区
   1. 存放数据，分为五部分
      1. Stack 虚拟机栈
      2. Heap 堆
      3. Method Area 方法区
      4. PC Register 程序计数器
      5. Native Method Stack 本地方法栈
3. Execution Engine 执行引擎
   1. 将 JVM 指令集翻译为操作系统指令集。
4. Native Interface 本地库接口
   1. 负责调用本地接口

1. JVM的装入环境和配置
2. 装载JVM
3. 初始化JVM，获得本地调用接口
4. 运行Java程序

1. Java 源代码文件经过 Java 编译器编译成字节码文件后，通过类加载器加载到内存中，然后到 Java 虚拟机中解释执行，最后通过操作系统操作 CPU 执行获取结果。

1. 程序计数器
   1. 当前线程所执行的字节码的行号指示器
2. Java虚拟机栈
   1. 描述的是Java方法执行的线程内存模型
   2. 每个方法被执行的时候，Java虚拟机都会同步创建一个栈帧
3. 本地方法栈
   1. 是为虚拟机使用到的本地（Native）方法服务。
4. Java堆
   1. 几乎所有的对象实例以及数组都应当在堆上分配
5. 方法区
   1. 用于存储已被虚拟机加载的类型信息、常量、静态变量、即时编译器编译后的代码缓存等数据
6. 运行时常量池
   1. 是方法区的一部分
7. 直接内存

1. 方法区

1. 虚拟机栈

1. 准备过程
   1. 初始化插入式注解处理器。
2. 解析与填充符号表
   1. 将源代码的字符流转变为标记集合，构造出抽象语法树。
   2. 填充符号表，产生符号地址和符号信息。
3. 插入式注解处理器的注解处理过程
   1. initPorcessAnnotations()
4. 分析与字节码生成过程
   1. 标注检查
   2. 数据流及控制流分析
   3. 解语法糖
   4. 字节码生成

1. 加载
   1. 通过全限定名来获取定义此类的二进制字节流。
   2. 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
   3. 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。
2. 验证
   1. 文件格式验证
      1. 验证字节流是否符合Class文件格式的规范，并且能被当前版本的虚拟机处理。
   2. 元数据验证
      1. 对字节码描述的信息进行语义分析验证
   3. 字节码验证
      1. 确定程序语义是合法的、符合逻辑的。
   4. 符号引用验证
      1. 对类自身以外的各类信息进行匹配性校验
3. 准备
   1. 正式为类中定义的变量分配内存并设置类变量初始值的阶段
4. 解析
   1. Java虚拟机将常量池内的符号引用替换为直接引用的过程
5. 初始化
   1. 执行类构造器<clinit>()(Javac)编译器的自动生成物方法的过程

1. 栈外，元空间占用的是本地内存

1. 把类的加载阶段(通过全限定名获取二进制字节流)放到JVM外部实现的动作代码
2. 双亲委派模型
   1. 工作过程
      1. 如果一个类加载器收到了类加载的请求首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成；只有当父加载器反馈自己无法完成这个加载请求（它的搜索范围中没有找到所需的类）时，子加载器才会尝试自己去完成加载。
   2. 好处
      1. Java中的类随着它的类加载器一起具备了一种带有优先级的层次关系

1. 双亲委派模型主要出现过3次较大规模“被破坏”的情况。

1. 哪些内存需要回收
   1. 处于运行期间程序创建的对象
2. 怎么定义垃圾
   1. 引用计数算法
      1. 在对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加一；当引用失效时，计数器值就减一；任何时刻计数器为零的对象就是不可能再被使用的。
         
      2. 缺点
         1. 有很多例外情况要考虑要配合大量额外处理才能保证正确地工作，比如对象之间相互循环引用的问题。
   2. 可达性分析算法
      1. 某个对象到GC Roots(起始节点集)间没有任何引用链相连明此对象是不可能再被使用的。
         1. 固定作为GC Roots的对象：
            1. 在虚拟机栈（栈帧中的本地变量表）中引用的对象
            2. 在方法区中类静态属性引用的对象
            3. 在方法区中常量引用的对象
            4. Native方法引用的对象
            5. Java虚拟机内部的引用
            6. 被同步锁持有的对象。
            7. 映Java虚拟机内部情况的JMXBean、JVMTI中注册的回调、本地代码缓存等。
   3. 回收方法区
      1. 方法区的垃圾收集主要回收两部分内容：废弃的常量和不再使用的类型
3. 怎么回收垃圾
   1. 分代收集理论
      1. 收集器将Java堆划分出不同的区域，将回收对象依据其年龄分配到不同的区域之中存储
   2. 标记-清除算法
      1. 首先标记出所有需要回收的对象，在标记完成后，统一回收掉所有被标记的对象，
      2. 缺点：
         1. 执行效率不稳定
         2. 内存空间的碎片化
   3. 标记-复制算法
      1. 将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后再把已使用过的内存空间一次清理掉
      2. 缺点：
         1. 浪费内存空间
         2. 对象存活率高时要进行较多复制操作，效率低下
   4. 标记-整理算法
      1. 首先标记出所有需要回收的对象，让所有存活的对象都向内存空间一端移动，然后直接清理掉边界以外的内存

1. Full GC会“Stop The World”全程暂停用户的应用程序。

1. 新创建的对象一般会被分配在新生代中，Eden 区全部挤满Minor GC 就触发
2. 根据老年代剩余空间与新生代中对象的大小
   1. 老年代剩余多—>直接Minor GC
   2. 老年代剩余少 —> 检查老年代剩余空间与历次Minor GC生育对象的大小
      1. 老年代剩余大于历次Minor GC剩余对象 —>进行Minor GC
      2. 老年代剩余小于历次Minor GC剩余对象 —>进行Full GC
3. Minor GC之后有三种情况
   1. Minor GC之后的对象足够放到Survivor区，GC结束
   2. 不够放到Survivor区，接着放入老年代，老年代放得下，GC结束
   3. 老年代放不下 Full GC

1. 当 Eden 区的空间耗尽时
2. 减少策略
   1. 增加方法区、老年代空间
   2. 减少新生代
   3. 使用标记-整理算法
   4. 排查无用对象

1. JVM给每个对象定义了一个年龄计数器，对象每熬过一次Minor GC，年龄+1，年龄达到一定程度(默认15)晋升到老年代

1. 老年代的对象都是难以消亡的，复制会操作会很多，效率很低

1. 实际上98%的对象熬不过第一轮收集，所以标记-复制算法中不需要按1:1的比例划分内存
2. Apple式回收把新生代分为较大的Eden区和两块较小的Survivor，每次分配只在Eden和一块Survivor，另一块用来复制
3. 默认比例是8:1

1. 解决内存碎片化
2. 保证永远有一个Survivor区是空的，另一个非空Survivor是无碎片的
3. 再细分容易导致Survivor区被填满

1. 兼顾垃圾回收的时间开销和内存空间的有效利用

请介绍G1垃圾收集器

1. 主要面向服务端，自JDK9，开创了收集器面向局部收集的设计思路和基于Region的内存布局形式
2. 把连续的Java堆划分为多个大小相等的独立区域(Region)，每一个Region可以根据需要扮演Eden、Survivor、老年代
3. Region的特殊区域Humongous用来存储大对象(超过了一个Region一半)
4. 好处
   1. 每次收集到的内存空间都是Region的整数倍，避免了全区域的垃圾收集
   2. 根据用户设定的收集停顿时间，优先处理回收价值收益最大的Region(Garbage First的由来)

请介绍CMS垃圾收集器

1. 一种以获取最短回收停顿时间为目标的收集器，基于标记-清除算法
2. 运作过程
   1. 初始标记 (需要STOP THE WORLD)
   2. 并发标记 (需要STOP THE WORLD)
   3. 重新标记
   4. 并发清除
3. 缺点：
   1. 会因为占用了一部分线程导致应用程序变慢，降低总吞吐量
   2. 有可能出现Con-current Mode Failure导致Full Gc
   3. 收集结束时会产生大量碎片空间

1. 内存泄漏 memory leak
   1. 指程序运行过程中分配的内存用完后没有被GC回收，始终在占用内存，既不能使用又被分配
2. 内存溢出 out of memory
   1. 申请的内存大于能够提升的内存导致无法申请到足够的内存

1. 尽早释放无用对象的引用
2. 避免在循环中创建对象
3. 使用字符串时尽量使用StringBuildrer
4. 少使用静态变量

1. 内存溢出的原因
   1. 内存加载数据量过大，如一次从数据库中取出过多数据
   2. 存在死循环或循环产生太多重复对象
   3. 启动参数内存值设定太小
   4. 集合类中对象的引用使用后为清空，是的JVM不能回收
2. 解决
   1. 修改JVM参数直接增加内存
   2. 检查异常
   3. 使用内存查看工具动态查看内存使用情况
   4. 排查代码中的循环

1. Java堆溢出
   1. 对象总容量触及到最大堆容量时
2. 虚拟机栈和本地方法溢出
   1. 无法申请到足够的内存时
3. 方法区和运行时常量池溢出
   1. 运行时生成大量动态类的场景
4. 本地内存直接溢出