最详细的Jvm总结

---

一、Java的运行路径

  java->class文件->jvm(虚拟机)->操作系统->硬件层面(010101的机器码)。
  JVM各种折腾[内部结构、执行方式、垃圾回收、本地调用等]。
特点：一次编译到处运行

二、编译原理

  Person.java -> 词法分析器 -> tokens流 -> 语法分析器 -> 语法树/抽象语法树。
-> 语义分析器 -> 注解抽象语法树 -> 字节码生成器 -> Person.class文件。

三丶类加载机制

装载：

查找和导入class文件
（1）通过一个类的全限定名获取定义此类的二进制字节流。
（2）将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
（3）在Java堆中生成一个代表这个类的java.lang.Class对象，作为对方法区中这些数据的访问入口。

方法区和堆
  Class对象封装了类在方法区内的数据结构，并且向Java程序员提供了访问方法区内的数据结构的接口。在 Java堆中生成一个代表这个类的java.lang.Class对象，作为对方法区中这些数据的访问入口 （对象不一定都在堆，对象可能在栈上分配）。

链接：

(1)、验证(Verify)：

保证被加载类的正确性(贯穿整个流程的过程，要用到的时候才会去验证)

文件格式验证
元数据验证
字节码验证
符号引用验证

(2)、准备(Prepare)

为类的静态变量分配内存，并将其初始化为默认值

注：没有赋值但是不是静态就不行，编译不通过

(3)、解析(Resolve)

把类中的符号引用转换为直接引用
解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。
解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用限定符7类符号引用进行

  符号引用就是一组符号来描述目标，可以是任何字面量。
  直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄。

初始化

对类的静态变量，静态代码块执行初始化操作

四丶类加载器(classloader)

  在装载(Load)阶段，其中第(1)步:通过类的全限定名获取其定义的二进制字节流，需要借助类装载器完成，顾名思义，就是用来装载Class文件的。

加载原则(双亲委派)父类委托机制

1. 检查某个类是否已经加载

  自底向上，从Custom ClassLoader到BootStrap ClassLoader逐层检查，只要某个Classloader已加载，就视为已加载此类，保证此类所有ClassLoader加载一次。

2. 加载的顺序

自顶向下，也就是由上层来逐层尝试加载此类

破坏双亲委派

  复写，spi服务提供接口(java虚拟机时java的基石)可扩展能力，osgi(复写，热更新，热部署)。

五丶运行时数据区(Run-Time Data Areas)

在装载阶段的第(2),(3)步可以发现有运行时数据，堆，方法区等名词 。

(2)将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
(3)在Java堆中生成一个代表这个类的java.lang.Class对象，作为对方法区中这些数据的访问入口 。
说白了就是类文件被类装载器装载进来之后，类中的内容(比如变量，常量，方法，对象等这些数据得要 。

有个去处，也就是要存储起来，存储的位置肯定是在JVM中有对应的空间) 。

Method Area(方法区)

(1)方法区是各个线程共享的内存区域，在虚拟机启动时创建
(2)虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却又一个别名叫做Non-Heap(非 堆)，目的是与Java堆区分开来
(3)用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据
(4)当方法区无法满足内存分配需求时，将抛出OutOfMemoryError异常
此时回看装载阶段的第2步，将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
如果这时候把从Class文件到装载的第(1)和(2)步合并起来理解的话，可以画个图

JVM运行时数据区是一种规范，真正的实现 在JDK 8中就是Metaspace，在JDK6或7中就是Perm Space

Heap(堆)

(1)Java堆是Java虚拟机所管理内存中最大的一块，在虚拟机启动时创建，被所有线程共享。
(2)Java对象实例以及数组都在堆上分配。
此时回看装载阶段的第3步，在Java堆中生成一个代表这个类的java.lang.Class对象，作为对方法区中这些数据的访问入口

Stacks(虚拟机栈)

(1)虚拟机栈是一个线程执行的区域，保存着一个线程中方法的调用状态。换句话说，一个Java线程的运行状态，由一个虚拟机栈来保存，所以虚拟机栈肯定是线程私有的，独有的，随着线程的创建而创建。
(2)每一个被线程执行的方法，为该栈中的栈帧，即每个方法对应一个栈帧。调用一个方法，就会向栈中压入一个栈帧；一个方法调用完成，就会把该栈帧从栈中弹出

栈针：

栈帧：每个栈帧对应一个被调用的方法，可以理解为一个方法的运行空间
每个栈帧中包括局部变量表(Local Variables)、操作数栈(Operand Stack)、指向运行时常量池的引用(A)
reference to the run-time constant pool)、方法返回地址(Return Address)和附加信息。

1.局部变量表:方法中定义的局部变量以及方法的参数存放在这张表中 局部变量表中的变量不可直接使用，如需要使用的话，必须通过相关指令将其加载至操作数栈中作为操作数使 用。
2.操作数栈:以压栈和出栈的方式存储操作数的
3.动态链接:每个栈帧都包含一个指向运行时常量池中该栈帧所属方法的引用，持有这个引用是为了支持方法调用 过程中的动态连接(Dynamic Linking)。 (符号引用转变为直接引用)前面的解析找不到C 只能在动态这里从a找到c（多级调用是动态的）（支持方法多层级调用）

4.方法返回地址:当一个方法开始执行后,只有两种方式可以退出，一种是遇到方法返回的字节码指令；一种是遇 见异常，并且这个异常没有在方法体内得到处理。

The pc Register(程序计数器)

  我们都知道一个JVM进程中有多个线程在执行，而线程中的内容是否能够拥有执行权，是根据CPU调度来的。
  假如线程A正在执行到某个地方，突然失去了CPU的执行权，切换到线程B了，然后当线程A再获得CPU执行权的时候，怎么能继续执行呢？这就是需要在线程中维护一个变量，记录线程执行到的位置。
  如果线程正在执行Java方法，则计数器记录的是正在执行的虚拟机字节码指令的地址；
如果正在执行的是Native(本地方法)方法，则这个计数器为空。

Native Method Stacks(本地方法栈)

  如果当前线程执行的方法是Native类型的，这些方法就会在本地方法栈中执行。

六丶栈，堆，方法区的指向

栈指向堆

  如果在栈帧中有一个变量，类型为引用类型，比如Object obj=new Object()，这时候就是典型的栈中元素指向堆中的对象。

方法区指向堆

  方法区中会存放静态变量，常量等数据。如果是下面这种情况，就是典型的方法区中元素指向堆中的对象。
private static Object obj=new Object();

堆指向方法区

What？堆还能指向方法区？
  注意，方法区中会包含类的信息，堆中会有对象，那怎么知道对象是哪个类创建的呢？

七丶jvm内存模型

重点存储数据的是堆和方法区(非堆)

对象创建过程

  一般情况下，新创建的对象都会被分配到Eden区，一些特殊的大的对象会直接分配到Old区。

为什么需要Survivor区?只有Eden不行吗？

1. 如果没有Survivor,Eden区每进行一次Minor GC,存活的对象就会被送到老年代。
2. 这样一来，老年代很快被填满,触发Major GC(因为Major GC一般伴随着Minor GC,也可以看做触发了Full GC)。 只有经历16次Minor GC还能在新生代中存活的对象,才会被送到老年代。
3. Full GC(完全GC)=oldGc+YoungGc+MetaSpace(直接内存)

为什么需要两个Survivor区？

最大的好处就是解决了碎片化。
永远有一个Survivor space是空的,另一个非空的Survivor space无碎片。

新生代中Eden:S1:S2为什么是8:1:1？

收集算法来回收新生代

堆内存中都是线程共享的区域吗？

JVM默认为每个线程在Eden上开辟一个buffer区域，用来加速对象的分配，称之为TLAB，全称:Thread
Local Allocation Buffer。
对象优先会在TLAB上分配，但是TLAB空间通常会比较小，如果对象比较大，那么还是在共享区域分配。

八丶java对象内存模型

一个Java对象在内存中包括3个部分：对象头、实例数据和对齐填充（保证8的字节的倍数）（内存读取效率更高）

九丶垃圾回收

1丶如何确定一个对象是垃圾？

引用计数法：

对于某个对象而言，只要应用程序中持有该对象的引用，就说明该对象不是垃圾，如果一个对象没有任何指针对其引用，它就是垃圾。

弊端 : 如果AB相互持有引用，导致永远不能被回收。

可达性算法：

通过GC Root的对象，开始向下寻找，看某个对象是否可作为GC Root:类加载器、Thread、虚拟机栈的本地变量表、static成员、常量引用、本地方法栈的变量等。一条引用链(只有在这条链上就不是垃圾)
GCroot：不是根对象，可以是（局部变量表元素，静态变量，常量，本地方法栈的JNI（本地接口，本地方法））直接或者间接用到的对象
可达性：单向链表

2丶什么时候会垃圾回收？

GC是由JVM自动完成的，根据JVM系统环境而定，所以时机是不确定的。
调用System.gc()方法通知JVM进行一次垃圾回收

四种GC条件满足其一：

（1）当Eden区或者S区不够用了
（2）老年代空间不够用了
（3）方法区空间不够用了
（4）System.gc()

3丶垃圾收集算法

标记-清除

标记：

找出内存中需要回收的对象，并且把它们标记出来-----此时堆中所有的对象都会被扫描一遍，从而才能确定需要回收的对象，比较耗时

清除：

清除掉被标记需要回收的对象，释放出对应的内存空间

缺点：

标记清除之后会产生大量不连续的内存碎片，空间碎片太多可能会导致以后在程
序运行过程中需要分配较大对象时，无法找到足够的连续内存而不得不提前触发另一次垃圾收集动作。
(1)标记和清除两个过程都比较耗时，效率不高
(2)会产生大量不连续的内存碎片，空间碎片太多可能会导致以后在程序运行过程中需要分配较大对象时，无
法找到足够的连续内存而不得不提前触发另一次垃圾收集动作。

标记-复制

将内存划分为两块相等的区域，每次只使用其中一块
当其中一块内存使用完了，就将还存活的对象复制到另外一块上面，然后把已经使用过的内存空间一次清除掉。

缺点: 空间利用率降低。

标记-整理

随机整理(不连续性)，线行整理（234放一起，不管有没有内存随便），滑动整理（滑到一段，其他全部干掉）

Serial

它是一种单线程收集器，不仅仅意味着它只会使用一个CPU或者一条收集线程去完成垃圾收集工作，更
重要的是其在进行垃圾收集的时候需要暂停其他线程。
优点：简单高效，拥有很高的单线程收集效率
缺点：收集过程需要暂停所有线程
算法：复制算法
适用范围：新生代
应用：Client模式下的默认新生代收集器

Serial Old

Serial Old收集器是Serial收集器的老年代版本，也是一个单线程收集器，不同的是采用"标记-整理算法"，运行过程和Serial收集器一样。

ParNew

可以把这个收集器理解为Serial收集器的多线程版本
优点： 在多CPU时，比Serial效率高。
缺点： 收集过程暂停所有应用程序线程，单CPU时比Serial效率差。
算法： 复制算法
适用范围： 新生代
应用： 运行在Server模式下的虚拟机中首选的新生代收集器

Parallel Scavenge

Parallel Scavenge收集器是一个新生代收集器，它也是使用复制算法的收集器，又是并行的多线程收集器，看上去和ParNew一样，但是Parallel Scanvenge更关注系统的吞吐量。

吞吐量=运行用户代码的时间/(运行用户代码的时间+垃圾收集时间)比如虚拟机总共运行了100分钟，垃圾收集时间用了1分钟，吞吐量=(100-1)/100=99%。若吞吐量越大，意味着垃圾收集的时间越短，则用户代码可以充分利用CPU资源，尽快完成程序的运算任务。

-XX:MaxGCPauseMillis控制最大的垃圾收集停顿时间，
-XX:GCRatio直接设置吞吐量的大小。

Parallel Old

Parallel Old收集器是Parallel Scavenge收集器的老年代版本，使用多线程和标记-整理算法进行垃圾回收，也是更加关注系统的吞吐量。

CMS

采用的是"标记-清除算法",整个过程分为4步

(1)初始标记 CMS initial mark 标记GC Roots直接关联对象，不用Tracing，速度很快
(2)并发标记 CMS concurrent mark 进行GC Roots Tracing
(3)重新标记 CMS remark 修改并发标记因用户程序变动的内容
(4)并发清除 CMS concurrent sweep 清除不可达对象回收空间，同时有新垃圾产生，留着下次清理称为 浮动垃圾

优点： 并发收集、低停顿
缺点： 产生大量空间碎片、并发阶段会降低吞吐量

G1(Garbage-First)

  它将整个Java堆划分为多个大小相等的独立区域（Region），虽然还保留有新生代和老年代的概念，但新生代和老年代不再是物理隔离的了，它们都是一部分Region（不需要连续）的集合。

每个Region大小都是一样的，可以是1M到32M之间的数值，但是必须保证是2的n次幂
如果对象太大，一个Region放不下[超过Region大小的50%]，那么就会直接放到H中
设置Region大小：-XX:G1HeapRegionSize=M
所谓Garbage-Frist，其实就是优先回收垃圾最多的Region区域

（1）分代收集（仍然保留了分代的概念）
（2）空间整合（整体上属于“标记-整理”算法，不会导致空间碎片）
（3）可预测的停顿（比CMS更先进的地方在于能让使用者明确指定一个长度为M毫秒的时间片段内，消耗在垃圾收集上的时间不得超过N毫秒）

初始标记: (Initial Marking） 标记以下GC Roots能够关联的对象，并且修改TAMS的值，需要暂 停用户线程
并发标记: （Concurrent Marking） 从GC Roots进行可达性分析，找出存活的对象，与用户线程并发执行
最终标记: （Final Marking） 修正在并发标记阶段因为用户程序的并发执行导致变动的数据，需暂 停用户线程
筛选回收: （Live Data Counting and Evacuation） 对各个Region的回收价值和成本进行排序，根据 用户所期望的GC停顿时间制定回收计划

ZGC

JDK11新引入的ZGC收集器，不管是物理上还是逻辑上，ZGC中已经不存在新老年代的概念了
会分为一个个page，当进行GC操作时会对page进行压缩，因此没有碎片问题
只能在64位的linux上使用，目前用得还比较少

（1）可以达到10ms以内的停顿时间要求
（2）支持TB级别的内存
（3）堆内存变大后停顿时间还是在10ms以内

5丶垃圾收集器分类

串行收集器->Serial和Serial Old
只能有一个垃圾回收线程执行，用户线程暂停。
适用于内存比较小的嵌入式设备
并行收集器[吞吐量优先]->Parallel Scanvenge、Parallel Old
多条垃圾收集线程并行工作，但此时用户线程仍然处于等待状态。适用于科学计算、后台处理等若交互场景 。
并发收集器[停顿时间优先]->CMS、G1
用户线程和垃圾收集线程同时执行(但并不一定是并行的，可能是交替执行的)，垃圾收集线程在执行的时
候不会停顿用户线程的运行。
适用于相对时间有要求的场景，比如Web 。

6丶常见问题

吞吐量和停顿时间

停顿时间->垃圾收集器 进行 垃圾回收终端应用执行响应的时间
吞吐量->运行用户代码时间/(运行用户代码时间+垃圾收集时间)

停顿时间越短就越适合需要和用户交互的程序，良好的响应速度能提升用户体验； 高吞吐量则可以高效地利用CPU时间，尽快完成程序的运算任务，主要适合在后台运算而不需要太多交互 的任务。

小结 :这两个指标也是评价垃圾回收器好处的标准。

如何选择合适的垃圾收集器

优先调整堆的大小让服务器自己来选择

如果内存小于100M，使用串行收集器

如果是单核，并且没有停顿时间要求，使用串行或JVM自己选

如果允许停顿时间超过1秒，选择并行或JVM自己选

如果响应时间最重要，并且不能超过1秒，使用并发收集器

如何开启需要的垃圾收集器

（1）串行

-XX：+UseSerialGC

-XX：+UseSerialOldGC

（2）并行(吞吐量优先)：

-XX：+UseParallelGC

-XX：+UseParallelOldGC

（3）并发收集器(响应时间优先)

-XX：+UseConcMarkSweepGC

-XX：+UseG1GC

十丶JVM参数

标准参数

-version
-help
-server
-cp

-X参数

-Xint 解释执行

-Xcomp 第一次使用就编译成本地代码

-Xmixed 混合模式，JVM自己来决定

-XX参数

a.Boolean类型

格式：-XX:[±] +或-表示启用或者禁用name属性

比如：-XX:+UseConcMarkSweepGC 表示启用CMS类型的垃圾回收器

-XX:+UseG1GC 表示启用G1类型的垃圾回收器

b.非Boolean类型

格式：-XX=表示name属性的值是value

比如：-XX:MaxGCPauseMillis=500

其他参数

-Xms1000M等价于-XX:InitialHeapSize=1000M

-Xmx1000M等价于-XX:MaxHeapSize=1000M

-Xss100等价于-XX:ThreadStackSize=100

查看参数

java -XX:+PrintFlagsFinal -version > flags.txt

设置参数的常见方式

开发工具中设置比如IDEA，eclipse

运行jar包的时候:java -XX:+UseG1GC xxx.jar

web容器比如tomcat，可以在脚本中的进行设置

通过jinfo实时调整某个java进程的参数(参数只有被标记为manageable的flags可以被实时修改)

实践和单位换算

1Byte(字节)=8bit(位)

1KB=1024Byte(字节)

1MB=1024KB

1GB=1024MB

1TB=1024GB

十一丶内存

内存溢出(OOM)

一般会有两个原因：

（1）大并发情况下

（2）内存泄露导致内存溢出

内存泄露导致内存溢出

ThreadLocal引起的内存泄露，最终导致内存溢出

public class TLController { 
    @RequestMapping(value = "/tl") 
    public String tl(HttpServletRequest request) {
        ThreadLocal<Byte[]> tl = new ThreadLocal<Byte[]>(); // 1MB tl.set(new Byte[1024*1024]); return "ok"; 
    }}

十二丶 JVM性能优化指南

十三丶常见问题

内存泄漏与内存溢出的区别

内存泄漏是指不再使用的对象无法得到及时的回收，持续占用内存空间，从而造成内存空间的浪费。 内存泄漏很容易导致内存溢出，但内存溢出不一定是内存泄漏导致的。

young gc会有stw吗？

不管什么 GC，都会发送 stop-the-world，区别是发生的时间长短。而这个时间跟垃圾收集器又有关 系，Serial、PartNew、Parallel Scavenge 收集器无论是串行还是并行，都会挂起用户线程，而 CMS 和 G1 在并发标记时，是不会挂起用户线程的，但其它时候一样会挂起用户线程，stop the world 的时 间相对来说就小很多了。

major gc和full gc的区别

Major GC在很多参考资料中是等价于 Full GC 的，我们也可以发现很多性能监测工具中只有 Minor GC 和 Full GC。一般情况下，一次 Full GC 将会对年轻代、老年代、元空间以及堆外内存进行垃圾回收。触 发 Full GC 的原因有很多：当年轻代晋升到老年代的对象大小，并比目前老年代剩余的空间大小还要大 时，会触发 Full GC；当老年代的空间使用率超过某阈值时，会触发 Full GC；当元空间不足时（JDK1.7 永久代不足），也会触发 Full GC；当调用 System.gc() 也会安排一次 Full GC。

什么是直接内存?

Java的NIO库允许Java程序使用直接内存。直接内存是在java堆外的、直接向系统申请的内存空间。通 常访问直接内存的速度会优于Java堆。因此出于性能的考虑，读写频繁的场合可能会考虑使用直接内 存。由于直接内存在java堆外，因此它的大小不会直接受限于Xmx指定的最大堆大小，但是系统内存是 有限的，Java堆和直接内存的总和依然受限于操作系统能给出的最大内存

垃圾判断的方式?

引用计数法：指的是如果某个地方引用了这个对象就+1，如果失效了就-1，当为0就会回收但是JVM没 有用这种方式，因为无法判定相互循环引用（A引用B,B引用A）的情况。 引用链法： 通过一种GC ROOT的对象（方法区中静态变量引用的对象等-static变量）来判断，如果有 一条链能够到达GC ROOT就说明，不能到达GC ROOT就说明可以回收。

不可达的对象一定要被回收吗？

即使在可达性分析法中不可达的对象，也并非是“非死不可”的，这时候它们暂时处于“缓刑阶段”，要真 正宣告一个对象死亡，至少要经历两次标记过程；可达性分析法中不可达的对象被第一次标记并且进行 一次筛选，筛选的条件是此对象是否有必要执行 finalize 方法。当对象没有覆盖 finalize 方法，或 finalize 方法已经被虚拟机调用过时，虚拟机将这两种情况视为没有必要执行。 被判定为需要执行的对象将会被放在一个队列中进行第二次标记，除非这个对象与引用链上的任何一个 对象建立关联，否则就会被真的回收。

为什么要区分新生代和老年代？

当前虚拟机的垃圾收集都采用分代收集算法，这种算法没有什么新的思想，只是根据对象存活周期的不 同将内存分为几块。一般将 java 堆分为新生代和老年代，这样我们就可以根据各个年代的特点选择合 适的垃圾收集算法。 比如在新生代中，每次收集都会有大量对象死去，所以可以选择复制算法，只需要付出少量对象的复制 成本就可以完成每次垃圾收集。而老年代的对象存活几率是比较高的，而且没有额外的空间对它进行分 配担保，所以我们必须选择“标记-清除”或“标记-整理”算法进行垃圾收集

G1与CMS的区别是什么?

CMS 主要集中在老年代的回收，而 G1 集中在分代回收，包括了年轻代的 Young GC 以及老年代的 Mix GC；G1 使用了 Region 方式对堆内存进行了划分，且基于标记整理算法实现，整体减少了垃圾碎片的 产生；在初始化标记阶段，搜索可达对象使用到的 Card Table，其实现方式不一样

方法区中的无用类回收

方法区主要回收的是无用的类，那么如何判断一个类是无用的类的呢？ 判定一个常量是否是“废弃常量”比较简单，而要判定一个类是否是“无用的类”的条件则相对苛刻许多。 类需要同时满足下面 3 个条件才能算是 “无用的类” : a-该类所有的实例都已经被回收，也就是 Java 堆中不存在该类的任何实例。 b-加载该类的 ClassLoader 已经被回收。 c-该类对应的 java.lang.Class 对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法

---

总结

例如：以上就是今天要讲的JVM内容，希望对大家有所帮助，希望大家点赞支持一下作者谢谢！