2021 - 精心整理的 JVM 虚拟机常见面试题-【附详细答案】

喜欢ヅ旅行 2023-01-13 04:24 132阅读 0赞

**目录**

1. JVM运行时数据区是什么？

2. 请说一下JVM的类加载流程

3. JVM内存参数调优

4. Java中的垃圾回收算法？

5. 如何判断一个对象是否存活？

6. 有哪几种垃圾回收器，有哪些优缺点？cms和g1的区别？

7. 强引用、软应用、弱引用、虚引用的区别？

8. 说一下java虚拟机的基本结构

9. 内存模型以及分区，需要详细到每个区放什么？

10.说一下堆栈的区别？

11. 什么是双亲委派模型？

12. 怎么判断对象是否可以被回收？

13. 详细说一下垃圾收集器

14. 什么是类加载器，类加载器有哪些?

15. 描述一下 JVM 加载 Class 文件的原理机制?

16. 说一下Java 内存分配

17.Java 堆的结构是什么样子的？什么是堆中的永久代（Perm Genspace）?

18. Java 中会存在内存泄漏吗

19. 深拷贝和浅拷贝。

20. 说一下 JVM 调优的工具？

21. 常用的 JVM 调优的参数都有哪些？

22. JVM中一次完整的GC流程是怎样的，对象如何晋升到老年代

23. Minor GC、Major GC和Full GC之间的区别

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

### 关注我们，更多技术干货： ###

**[2000多G的计算机各行业电子资源分享（持续更新）][2000_G]**

**[2020年微信小程序全栈项目之喵喵交友【附课件和源码】][2020]**

**[Spring Boot开发小而美的个人博客【附课件和源码】][Spring Boot]**

**[Java微服务实战296集大型视频-谷粒商城【附代码和课件】][Java_296_-]**

**[Java开发微服务畅购商城实战【全357集大项目】-附代码和课件][Java_357_-]**

**[最全最详细数据结构与算法视频-【附课件和源码】][-]**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70_pic_center]

<table> 
 <tbody> 
  <tr> 
   <td> <p><strong>2021年JAVA 精心整理的常见面试题-附详细答案</strong></p> </td> 
   <td><a href="https://mikejun.blog.csdn.net/article/details/114488339" rel="nofollow">https://mikejun.blog.csdn.net/article/details/114488339</a></td> 
  </tr> 
  <tr> 
   <td> <p><strong>2021年- 精心整理的 SpringMVC 常见面试题-【附详细答案】</strong></p> </td> 
   <td><a href="https://mikejun.blog.csdn.net/article/details/114992529" rel="nofollow">https://mikejun.blog.csdn.net/article/details/114992529</a></td> 
  </tr> 
  <tr> 
   <td> <p><strong>2021年- 精心整理的 SpringBoot 常见面试题-【附详细答案】</strong></p> </td> 
   <td><a href="https://mikejun.blog.csdn.net/article/details/115682106" rel="nofollow">https://mikejun.blog.csdn.net/article/details/115682106</a></td> 
  </tr> 
  <tr> 
   <td> <p><strong>2021年JAVA 面试题之--数据结构篇【附详细答案】</strong></p> </td> 
   <td><a href="https://mikejun.blog.csdn.net/article/details/114647742" rel="nofollow">https://mikejun.blog.csdn.net/article/details/114647742</a></td> 
  </tr> 
  <tr> 
   <td> <p><strong>精心整理的计算机各类别的电子书籍【超全】</strong></p> </td> 
   <td><a href="https://mikejun.blog.csdn.net/article/details/115442555" rel="nofollow">https://mikejun.blog.csdn.net/article/details/115442555</a></td> 
  </tr> 
  <tr> 
   <td> <p><strong>三天刷完《剑指OFFER编程题》--Java版本实现（第一天）</strong></p> </td> 
   <td><a href="https://mikejun.blog.csdn.net/article/details/106996017" rel="nofollow">https://mikejun.blog.csdn.net/article/details/106996017</a></td> 
  </tr> 
  <tr> 
   <td> <p><strong>三天刷完《剑指OFFER编程题》--Java版本实现（第二天）</strong></p> </td> 
   <td><a href="https://mikejun.blog.csdn.net/article/details/108098502" rel="nofollow">https://mikejun.blog.csdn.net/article/details/108098502</a></td> 
  </tr> 
  <tr> 
   <td> <p><strong>三天刷完《剑指OFFER编程题》--Java版本实现（第三天）</strong></p> </td> 
   <td><a href="https://mikejun.blog.csdn.net/article/details/108253489" rel="nofollow">https://mikejun.blog.csdn.net/article/details/108253489</a></td> 
  </tr> 
 </tbody> 
</table>

###  ###

### 1. JVM运行时数据区是什么？ ###

其实JVM运行时数据区可以通过分类进行快速记忆，其中可以分为**线程共享**以及**线程私有**：

1.  线程共享的区域有：堆（感觉只要是学java的这个不可能答不出来）、方法区
    2.  线程私有的区域有：虚拟机栈(java方法)、本地方法栈(c/c++方法)、程序计数器

大体可以通过下图进行一个大概的了解：

![6bf166bb47f6d1a12521f31de5be3b22.png][]

上图已经很好的诠释了相应的内存划分，以及某些数据具体存储在哪，接下来我们根据这个图进行一个简单的总结：

1.  **程序计数器**是占用空间最小的内存区域，**不会出现OOM**，主要记录当前线程正在执行的方法的指令地址，**方便线程切换后能恢复到下一条指令的位置，**如果是执行native方法，则该计数器为空。（由于这块老是被遗忘，写在第一处让读者记忆深刻点）
2.  **虚拟机栈**是用来存放栈帧的，说白了栈帧就是方法运行时数据存储的空间，这栈帧主要由四个部分组成：
    
    Ⅰ. ***局部变量***，方法体里面包含的变量，如基本变量 int , float 等以及对象的引用如`Student s`
    
    Ⅱ. ***操作数栈***，对数据的运算需要一个栈来进行，可以理解为自己开发一个算术运算时使用的栈结构，如果有数据进行计算的时候会将数据放入，然后计算得出的结果也会存到这里面
    
    Ⅲ. ***动态链接***，存储了指向class常量池的方法符号引用(一个字符串)，说白了这个东西就是查找方法具体位置的一种懒加载机制。在第一次运行会通过这个字符串找到相应方法所在位置，之后将这个位置替换掉符号引用，变为直接引用。
    
    Ⅳ. ***返回地址***，这个应该很好理解，我得知道方法运行完后要回去哪，这个地址便是指向进入这个方法时候的地址，方便返回
3.  **本地方法栈**，与虚拟机栈差不多，只不过运行的是native(c/c++)方法
4.  **堆**，存储对象以及数组的区域，基本上是jvm内存里面最大的区域。

> PS：如果方法里面的一个对象不存在被外界调用，那么jvm可能会将这个对象存放在栈里面，不过目前怎么判断一个对象不怎么被外界调用（即逃逸分析）不太成熟，知道这个的人也不多（面试就遇到一回问这个）。

1.  **方法区**，主要存储虚拟机加载的类信息、常量、静态变量，例如上面说的符号引用也存在这。

> PS: 读者对于方法区最大的疑惑可能就是jdk1.8后的变化，其实jdk1.8前方法区属于堆的一个子集，只不过1.8之后变成了和堆的并交（如图中所示），其中类的元信息存储在直接内存，而常量池、静态变量的引用对象还是存在堆中。

**JVM每遇到一个线程，就为其分配一个程序计数器，虚拟机栈和本地方法栈，栈里面指向的对象一般都在堆中，线程终止的时候便会清空这些内存 ( 以上都是线程私有，因此和线程共存亡 ) ，而堆中的对象则根据可达性分析算法进行生死判断**

### 2. 请说一下JVM的类加载流程 ###

![2acd352359aed98f186978c123e6ba1d.png][]

**将 Class 文件的字节流转换为方法区中的 Class 对象**（加载），**检查该 Class 文件的字节流是否规范、合法**（验证），**为该 Class 的类变量( static )进行空间分配**（准备）**，对该 Class 中的符号引用转换为直接引用**（解析），**最后执行用户编写的构造器代码**（初始化）

*PS* : 其中准备阶段和解析阶段有些小细节，准备阶段如果是类常量( static final )，则会直接进行**赋值操作**，否则**赋予初始值**( int 就赋值0，对象就赋值 null 等)，在初始化阶段才会进行具体赋值；而解析阶段则可能是一个懒加载情况，有可能是在初始化后被其他对象进行调用才会将符号引用转为直接引用。

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

类加载还有一个重要的考点就是**类加载机制** ，也就是所谓的**双亲委派机制**，即从下往上抛类的信息，优先由上层负责加载，如果上层加载失败，则往下抛，如果最底层的加载器也无法加载，则抛出 ClassNotFoundException 异常；**这个机制的作用就是为了防止核心类被第三方类进行调包操作，防止多个系统级别的 Class 生成。**

然而，这个机制也挖了不少坑，例如A类调用B类，则B类的加载得由加载A类的类加载器完成；但是 jdbc 核心类由 **bootstrap类加载器** 加载，而这个加载器只会加载lib/rt.jar而无法加载第三方的jar类，便会出现第三方数据库厂商jar无法**被动加载**的情况。  
`所谓的主动加载其实就是我们用户通过 Class.forName() 进行类加载，被动加载则是无需我们通过编写这类代码进行该类的加载`  
这个时候就引入**SPI 和线程上下文类加载器( Thread Context ClassLoader )**来加载第三方的jar，所以为什么新版的 mysql 驱动包无需我们手动进行类加载也可以自动加载(旧版的没有用上面提到的加载器)。一般来说这个线程上下文类加载器就是 Application-ClassLoader，所以可以直接加载，但是这种用法从某种意义上属于打破双亲委派机制的一种情况，因为需要由启动类加载器进行加载的类，由应用程序类加载器去进行加载了。

### 3. JVM内存参数调优 ###

JVM内存调优主要表现在对JVM内存参数的设定上，通过设置符合生产情况来**稳定项目的运行，而不是提高运行性能**，我们主要看设置的最频繁的参数列表，其余参数目前来说大部分内存参数的默认情况可以基本符合线上需求

<table> 
 <thead> 
  <tr> 
   <th>示例参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>-Xms20m</td> 
   <td>堆初始值20M ，等同于-XX:InitalHeapSize=20m，默认为物理内存的1/64</td> 
  </tr> 
  <tr> 
   <td>-Xmx20m</td> 
   <td>堆最大可用值20M ，等同于-XX:MaxHeapSize=20m，默认为物理内存的1/4</td> 
  </tr> 
  <tr> 
   <td>-Xss1m</td> 
   <td>单个线程栈的大小，等同于-XX:ThreadStackSize，一般默认512k~1024k</td> 
  </tr> 
 </tbody> 
</table>

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

1.  我们尽量将堆的初始值和最大值设置一样，**这样做的好处是为了防止JVM在内存不够的时候向OS申请内存以及GC回收后JVM释放部分内存导致的性能下降**，在初始化的时候限制死JVM的大小，具体设置多大看具体的项目情况。如果经常出现OOM或FULL GC，可以考虑是否为JVM堆设置的过小，或者是否发生内存泄漏。
2.  xss参数设置的越大，那么可创建的线程数量便越少，因为每个线程栈占用的空间越多，导致可用的内存越少；同时，如果设置堆的内存越大，可创建的线程也会变少，**因为线程不在堆内存上创建，JVM只是创建了一个Thread对象，线程在堆内存之外的内存上创建**，由OS具体生成，堆给的内存越多，那么OS可使用的内存越少。**所以如果项目比较少用到递归或者深度较大的方法，那么这个值可以相对设置小一点，以免出现无法创建线程的OOM。**

### 4. Java中的垃圾回收算法？ ###

java中有四种垃圾回收算法，分别是：

标记清除法、标记整理法、复制算法、分代收集算法；

**标记清除法：**

第一步：利用可达性去遍历内存，把存活对象和垃圾对象进行标记；

第二步：在遍历一遍，将所有标记的对象回收掉；特点：效率不行，标记和清除的效率都不高；标记和清除后会产生大量的不连续的空间分片，可能会导致之后程序运行的时候需分配大对象而找不到连续分片而不得不触发一次GC；

**标记整理法：**

第一步：利用可达性去遍历内存，把存活对象和垃圾对象进行标记；

第二步：将所有的存活的对象向一段移动，将端边界以外的对象都回收掉；特点：适用于存活对象多，垃圾少的情况；需要整理的过程，无空间碎片产生；

**复制算法：**

将内存按照容量大小分为大小相等的两块，每次只使用一块，当一块使用完了，就将还存活的对象移到另一块上，然后在把使用过的内存空间移除；特点：不会产生空间碎片；内存使用率极低；

**分代收集算法：**

根据内存对象的存活周期不同，将内存划分成几块，java虚拟机一般将内存分成新生代和老生代，在新生代中，有大量对象死去和少量对象存活，所以采用复制算法，只需要付出少量存活对象的复制成本就可以完成收集；老年代中因为对象的存活率极高，没有额外的空间对他进行分配担保，所以采用标记清理或者标记整理算法进行回收；

> **标记-清除算法：**标记无用对象，然后进行清除回收。缺点：效率不高，无法清除垃圾碎片。
> 
> **标记-整理算法：**标记无用对象，让所有存活的对象都向一端移动，然后直接清除掉端边界以外的内存。
> 
> **复制算法：**按照容量划分二个大小相等的内存区域，当一块用完的时候将活着的对象复制到另一块上，然后再把已使用的内存空间一次清理掉。缺点：内存使用率不高，只有原来的一半。
> 
> **分代算法：**根据对象存活周期的不同将内存划分为几块，一般是新生代和老年代，新生代基本采用复制算法，老年代采用标记整理算法。

### 5. 如何判断一个对象是否存活？ ###

判断一个对象是否存活，分为两种算法：

1.引用计数法；

2.可达性分析算法；

**引用计数法：**

给每一个对象设置一个引用计数器，当有一个地方引用该对象的时候，引用计数器就+1，引用失效时，引用计数器就-1；当引用计数器为0的时候，就说明这个对象没有被引用，也就是垃圾对象，等待回收；缺点：无法解决循环引用的问题，当A引用B，B也引用A的时候，此时AB对象的引用都不为0，此时也就无法垃圾回收，所以一般主流虚拟机都不采用这个方法；

**可达性分析法：**

从一个被称为GC Roots的对象向下搜索，如果一个对象到GC Roots没有任何引用链相连接时，说明此对象不可用，在java中可以作为GC Roots的对象有以下几种：

虚拟机栈中引用的对象方法区类静态属性引用的变量方法区常量池引用的对象本地方法栈JNI引用的对象但一个对象满足上述条件的时候，不会马上被回收，还需要进行两次标记；第一次标记：判断当前对象是否有finalize()方法并且该方法没有被执行过，若不存在则标记为垃圾对象，等待回收；若有的话，则进行第二次标记；第二次标记将当前对象放入F-Queue队列，并生成一个finalize线程去执行该方法，虚拟机不保证该方法一定会被执行，这是因为如果线程执行缓慢或进入了死锁，会导致回收系统的崩溃；如果执行了finalize方法之后仍然没有与GC Roots有直接或者间接的引用，则该对象会被回收。

### 6. 有哪几种垃圾回收器，有哪些优缺点？cms和g1的区别？ ###

垃圾回收器主要分为以下几种：

Serial、ParNew、Parallel Scavenge、Serial Old、Parallel Old、CMS、G1。

**Serial:**

单线程的收集器，收集垃圾时，必须stop the world，使用复制算法。

**ParNew:**

Serial收集器的多线程版本，也需要stop the world，复制算法.

**ParallelScavenge:**

新生代收集器，复制算法的收集器，并发的多线程收集器，目标是达到一个可控的吞吐量，和ParNew的最大区别是GC自动调节策略；虚拟机会根据系统的运行状态收集性能监控信息，动态设置这些参数，以提供最优停顿时间和最高的吞吐量；

**Serial Old：**

Serial收集器的老年代版本，单线程收集器，使用标记整理算法。

**Parallel Old：**

是Parallel Scavenge收集器的老年代版本，使用多线程，标记-整理算法。

**CMS:**

是一种以获得最短回收停顿时间为目标的收集器，标记清除算法，运作过程：初始标记，并发标记，重新标记，并发清除，收集结束会产生大量空间碎片；

**G1:**

标记整理算法实现，运作流程主要包括以下：初始标记，并发标记，最终标记，筛选回收。不会产生空间碎片，可以精确地控制停顿；G1将整个堆分为大小相等的多个Region（区域），G1跟踪每个区域的垃圾大小，在后台维护一个优先级列表，每次根据允许的收集时间，优先回收价值最大的区域，已达到在有限时间内获取尽可能高的回收效率；

### 7. 强引用、软应用、弱引用、虚引用的区别？ ###

**强引用：**

强引用是我们使用最广泛的引用，如果一个对象具有强引用，那么垃圾回收期绝对不会回收它，当内存空间不足时，垃圾回收器宁愿抛出OutOfMemoryError，也不会回收具有强引用的对象；我们可以通过显示的将强引用对象置为null，让gc认为该对象不存在引用，从而来回收它；

**软引用：**

软应用是用来描述一些有用但不是必须的对象，在java中用SoftReference来表示，当一个对象只有软应用时，只有当内存不足时，才会回收它；软引用可以和引用队列联合使用，如果软引用所引用的对象被垃圾回收器所回收了，虚拟机会把这个软引用加入到与之对应的引用队列中；

**弱引用：**

弱引用是用来描述一些可有可无的对象，在java中用WeakReference来表示，在垃圾回收时，一旦发现一个对象只具有软引用的时候，无论当前内存空间是否充足，都会回收掉该对象；弱引用可以和引用队列联合使用，如果弱引用所引用的对象被垃圾回收了，虚拟机会将该对象的引用加入到与之关联的引用队列中；

**虚引用：**

虚引用就是一种可有可无的引用，无法用来表示对象的生命周期，任何时候都可能被回收，虚引用主要使用来跟踪对象被垃圾回收的活动，虚引用和软引用与弱引用的区别在于：虚引用必须和引用队列联合使用；在进行垃圾回收的时候，如果发现一个对象只有虚引用，那么就会将这个对象的引用加入到与之关联的引用队列中，程序可以通过发现一个引用队列中是否已经加入了虚引用，来了解被引用的对象是否需要被进行垃圾回收。

### 8. 说一下**java虚拟机的基本结构** ###

![1004ba9105b4a1601e17a86ba756759d.png][]

1）类加载子系统负责从文件系统或者网络中加载Class信息，加载的类信息存放于一块称为方法区的内存空间。除了类的信息外，方法区中可能还会存放运行时常量池信息，包括字符串字面量和数字常量（这部分常量信息是Class文件中常量池部分的内存映射）。

2）java堆在虚拟机启动的时候建立，它是java程序最主要的内存工作区域。几乎所有的java对象实例都存放在java堆中。堆空间是所有线程共享的，这是一块与java应用密切相关的内存空间。

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

4）垃圾回收系统是java虚拟机的重要组成部分，垃圾回收器可以对方法区、java堆和直接内存进行回收。其中，java堆是垃圾收集器的工作重点。和C/C++不同，java中所有的对象空间释放都是隐式的，也就是说，java中没有类似free()或者delete()这样的函数释放指定的内存区域。对于不再使用的垃圾对象，垃圾回收系统会在后台默默工作，默默查找、标识并释放垃圾对象，完成包括java堆、方法区和直接内存中的全自动化管理。

5）每一个java虚拟机线程都有一个私有的java栈，一个线程的java栈在线程创建的时候被创建，java栈中保存着帧信息，java栈中保存着局部变量、方法参数，同时和java方法的调用、返回密切相关。

6）本地方法栈和java栈非常类似，最大的不同在于java栈用于方法的调用，而本地方法栈则用于本地方法的调用，作为对java虚拟机的重要扩展，java虚拟机允许java直接调用本地方法（通常使用C编写）

7）PC（Program Counter）寄存器也是每一个线程私有的空间，java虚拟机会为每一个java线程创建PC寄存器。在任意时刻，一个java线程总是在执行一个方法，这个正在被执行的方法称为当前方法。如果当前方法不是本地方法，PC寄存器就会指向当前正在被执行的指令。如果当前方法是本地方法，那么PC寄存器的值就是undefined

8)执行引擎是java虚拟机的最核心组件之一，它负责执行虚拟机的字节码，现代虚拟机为了提高执行效率，会使用即时编译技术将方法编译成机器码后再执行。

### 9. **内存模型以及分区，需要详细到每个区放什么？** ###

JVM 分为堆区和栈区，还有方法区，初始化的对象放在堆里面，引用放在栈里面，class类信息常量池（static常量和static变量）等放在方法区

方法区：主要是存储类信息，常量池（static常量和static变量），编译后的代码（字节码）等数据

堆：初始化的对象，成员变量 （那种非static的变量），所有的对象实例和数组都要在堆上分配

栈：栈的结构是栈帧组成的，调用一个方法就压入一帧，帧上面存储局部变量表，操作数栈，方法出口等信息，局部变量表存放的是8大基础类型加上一个应用类型，所以还是一个指向地址的指针

本地方法栈：主要为Native方法服务

程序计数器：记录当前线程执行的行号

### **10.说一下堆栈的区别？** ###

> **功能方面：**堆是用来存放对象的，栈是用来执行程序的。
> 
> **共享性：**堆是线程共享的，栈是线程私有的。
> 
> **空间大小：**堆大小远远大于栈。

### **11. 什么是双亲委派模型？** ###

在介绍双亲委派模型之前先说下类加载器。对于任意一个类，都需要由加载它的类加载器和这个类本身一同确立在 JVM 中的唯一性，每一个类加载器，都有一个独立的类名称空间。类加载器就是根据指定全限定名称将 class 文件加载到 JVM 内存，然后再转化为 class 对象。

**类加载器分类：**

*  启动类加载器（Bootstrap ClassLoader），是虚拟机自身的一部分，用来加载Java\_HOME/lib/目录中的，或者被 -Xbootclasspath 参数所指定的路径中并且被虚拟机识别的类库；
 *  其他类加载器：
 *  扩展类加载器（Extension ClassLoader）：负责加载\\lib\\ext目录或Java. ext. dirs系统变量指定的路径中的所有类库；
 *  应用程序类加载器（Application ClassLoader）。负责加载用户类路径（classpath）上的指定类库，我们可以直接使用这个类加载器。一般情况，如果我们没有自定义类加载器默认就是用这个加载器。

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

### ![28606ae43740f6b551c1c9ce6835ec10.png][]      **12. 怎么判断对象是否可以被回收？** ###

> **一般有两种方法来判断：**
> 
> **引用计数器：**为每个对象创建一个引用计数，有对象引用时计数器 +1，引用被释放时计数 -1，当计数器为 0 时就可以被回收。它有一个缺点不能解决循环引用的问题；
> 
> **可达性分析：**从 GC Roots 开始向下搜索，搜索所走过的路径称为引用链。当一个对象到 GC Roots 没有任何引用链相连时，则证明此对象是可以被回收的。

判断一个对象是否存活有两种方法：

**1. 引用计数法**

所谓引用计数法就是给每一个对象设置一个引用计数器，每当有一个地方引用这个对象时，就将计数器加一，引用失效时，计数器就减一。当一个对象的引用计数器为零时，说明此对象没有被引用，也就是“死对象”,将会被垃圾回收。

引用计数法有一个缺陷就是无法解决循环引用问题，也就是说当对象 A 引用对象 B，对象 B 又引用者对象 A，那么此时 A、B 对象的引用计数器都不为零，也就造成无法完成垃圾回收，所以主流的虚拟机都没有采用这种算法。

**2. 可达性算法（引用链法）**

该算法的思想是：从一个被称为 GC Roots 的对象开始向下搜索，如果一个对象到 GC Roots 没有任何引用链相连时，则说明此对象不可用。

在 Java 中可以作为 GC Roots 的对象有以下几种：

• 虚拟机栈中引用的对象

• 方法区类静态属性引用的对象

• 方法区常量池引用的对象

• 本地方法栈 JNI 引用的对象

虽然这些算法可以判定一个对象是否能被回收，但是当满足上述条件时，一个对象比不一定会被回收。当一个对象不可达 GC Root时，这个对象并不会立马被回收，而是出于一个死缓的阶段，若要被真正的回收需要经历两次标记。

如果对象在可达性分析中没有与 GC Root 的引用链，那么此时就会被第一次标记并且进行一次筛选，筛选的条件是是否有必要执行finalize() 方法。当对象没有覆盖 finalize() 方法或者已被虚拟机调用过，那么就认为是没必要的。 如果该对象有必要执行finalize() 方法，那么这个对象将会放在一个称为 F-Queue 的对队列中，虚拟机会触发一个 Finalize() 线程去执行，此线程是低优先级的，并且虚拟机不会承诺一直等待它运行完，这是因为如果finalize() 执行缓慢或者发生了死锁，那么就会造成 F-Queue 对列一直等待，造成了内存回收系统的崩溃。GC 对处于 F-Queue中的对象进行第二次被标记，这时，该对象将被移除” 即将回收”集合，等待回收。

### 13. 详细说一下垃圾收集器 ###

**如果说收集算法是内存回收的方法论，那么垃圾收集器就是内存回收的具体实现。**

虽然我们对各个收集器进行比较，但并非要挑选出一个最好的收集器。因为直到现在为止还没有最好的垃圾收集器出现，更加没有万能的垃圾收集器，**我们能做的就是根据具体应用场景选择适合自己的垃圾收集器**。试想一下：如果有一种四海之内、任何场景下都适用的完美收集器存在，那么我们的 HotSpot 虚拟机就不会实现那么多不同的垃圾收集器了。

**4.1 Serial 收集器**

Serial（串行）收集器收集器是最基本、历史最悠久的垃圾收集器了。大家看名字就知道这个收集器是一个单线程收集器了。它的 **“单线程”** 的意义不仅仅意味着它只会使用一条垃圾收集线程去完成垃圾收集工作，更重要的是它在进行垃圾收集工作的时候必须暂停其他所有的工作线程（ **"Stop The World"** ），直到它收集结束。

**新生代采用复制算法，老年代采用标记-整理算法。**

![bbbfec93ae9468e8b2efb98dc00b208f.png][]

虚拟机的设计者们当然知道 Stop The World 带来的不良用户体验，所以在后续的垃圾收集器设计中停顿时间在不断缩短（仍然还有停顿，寻找最优秀的垃圾收集器的过程仍然在继续）。

但是 Serial 收集器有没有优于其他垃圾收集器的地方呢？当然有，它**简单而高效（与其他收集器的单线程相比）**。Serial 收集器由于没有线程交互的开销，自然可以获得很高的单线程收集效率。Serial 收集器对于运行在 Client 模式下的虚拟机来说是个不错的选择。

**4.2 ParNew 收集器**

**ParNew 收集器其实就是 Serial 收集器的多线程版本，除了使用多线程进行垃圾收集外，其余行为（控制参数、收集算法、回收策略等等）和 Serial 收集器完全一样。**

**新生代采用复制算法，老年代采用标记-整理算法。**

![78546941d610c58b503fee33d48682fb.png][]

它是许多运行在 Server 模式下的虚拟机的首要选择，除了 Serial 收集器外，只有它能与 CMS 收集器（真正意义上的并发收集器，后面会介绍到）配合工作。

**并行和并发概念补充：**

*  **并行（Parallel）** ：指多条垃圾收集线程并行工作，但此时用户线程仍然处于等待状态。
 *  **并发（Concurrent）**：指用户线程与垃圾收集线程同时执行（但不一定是并行，可能会交替执行），用户程序在继续运行，而垃圾收集器运行在另一个 CPU 上。

**4.3 Parallel Scavenge 收集器**

Parallel Scavenge 收集器也是使用复制算法的多线程收集器，它看上去几乎和ParNew都一样。 **那么它有什么特别之处呢？**

-XX:+UseParallelGC 
    
        使用 Parallel 收集器+ 老年代串行
    
    -XX:+UseParallelOldGC
    
        使用 Parallel 收集器+ 老年代并行

**Parallel Scavenge 收集器关注点是吞吐量（高效率的利用 CPU）。CMS 等垃圾收集器的关注点更多的是用户线程的停顿时间（提高用户体验）。所谓吞吐量就是 CPU 中用于运行用户代码的时间与 CPU 总消耗时间的比值。** Parallel Scavenge 收集器提供了很多参数供用户找到最合适的停顿时间或最大吞吐量，如果对于收集器运作不太了解的话，手工优化存在困难的话可以选择把内存管理优化交给虚拟机去完成也是一个不错的选择。

**新生代采用复制算法，老年代采用标记-整理算法。**

![34388a554163ee17d23a2fea18635379.png][]

###  ###

**4.4.Serial Old 收集器**

**Serial 收集器的老年代版本**，它同样是一个单线程收集器。它主要有两大用途：一种用途是在 JDK1.5 以及以前的版本中与 Parallel Scavenge 收集器搭配使用，另一种用途是作为 CMS 收集器的后备方案。

**4.5 Parallel Old 收集器**

**Parallel Scavenge 收集器的老年代版本**。使用多线程和“标记-整理”算法。在注重吞吐量以及 CPU 资源的场合，都可以优先考虑 Parallel Scavenge 收集器和 Parallel Old 收集器。

**4.6 CMS 收集器**

**CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器。它非常符合在注重用户体验的应用上使用。**

**CMS（Concurrent Mark Sweep）收集器是 HotSpot 虚拟机第一款真正意义上的并发收集器，它第一次实现了让垃圾收集线程与用户线程（基本上）同时工作。**

从名字中的**Mark Sweep**这两个词可以看出，CMS 收集器是一种 **“标记-清除”算法**实现的，它的运作过程相比于前面几种垃圾收集器来说更加复杂一些。整个过程分为四个步骤：

*  **初始标记：** 暂停所有的其他线程，并记录下直接与 root 相连的对象，速度很快 ；
 *  **并发标记：** 同时开启 GC 和用户线程，用一个闭包结构去记录可达对象。但在这个阶段结束，这个闭包结构并不能保证包含当前所有的可达对象。因为用户线程可能会不断的更新引用域，所以 GC 线程无法保证可达性分析的实时性。所以这个算法里会跟踪记录这些发生引用更新的地方。
 *  **重新标记：** 重新标记阶段就是为了修正并发标记期间因为用户程序继续运行而导致标记产生变动的那一部分对象的标记记录，这个阶段的停顿时间一般会比初始标记阶段的时间稍长，远远比并发标记阶段时间短
 *  **并发清除：** 开启用户线程，同时 GC 线程开始对为标记的区域做清扫。

![20b2845b5a2b176525721044f7f30193.png][]

从它的名字就可以看出它是一款优秀的垃圾收集器，主要优点：**并发收集、低停顿**。但是它有下面三个明显的缺点：

*  **对 CPU 资源敏感；**
 *  **无法处理浮动垃圾；**
 *  **它使用的回收算法-“标记-清除”算法会导致收集结束时会有大量空间碎片产生。**

**4.7 G1 收集器**

**G1 (Garbage-First) 是一款面向服务器的垃圾收集器,主要针对配备多颗处理器及大容量内存的机器. 以极高概率满足 GC 停顿时间要求的同时,还具备高吞吐量性能特征.**

被视为 JDK1.7 中 HotSpot 虚拟机的一个重要进化特征。它具备一下特点：

*  **并行与并发**：G1 能充分利用 CPU、多核环境下的硬件优势，使用多个 CPU（CPU 或者 CPU 核心）来缩短 Stop-The-World 停顿时间。部分其他收集器原本需要停顿 Java 线程执行的 GC 动作，G1 收集器仍然可以通过并发的方式让 java 程序继续执行。
 *  **分代收集**：虽然 G1 可以不需要其他收集器配合就能独立管理整个 GC 堆，但是还是保留了分代的概念。
 *  **空间整合**：与 CMS 的“标记--清理”算法不同，G1 从整体来看是基于“标记整理”算法实现的收集器；从局部上来看是基于“复制”算法实现的。
 *  **可预测的停顿**：这是 G1 相对于 CMS 的另一个大优势，降低停顿时间是 G1 和 CMS 共同的关注点，但 G1 除了追求低停顿外，还能建立可预测的停顿时间模型，能让使用者明确指定在一个长度为 M 毫秒的时间片段内。

G1 收集器的运作大致分为以下几个步骤：

*  **初始标记**
 *  **并发标记**
 *  **最终标记**
 *  **筛选回收**

**G1 收集器在后台维护了一个优先列表，每次根据允许的收集时间，优先选择回收价值最大的 Region(这也就是它的名字 Garbage-First 的由来)**。这种使用 Region 划分内存空间以及有优先级的区域回收方式，保证了 GF 收集器在有限时间内可以尽可能高的收集效率（把内存化整为零）。

### 14. 什么是类加载器，类加载器有哪些? ###

实现通过类的权限定名获取该类的二进制字节流的代码块叫做类加载器。

主要有一下四种类加载器:

**1. 启动类加载器**(Bootstrap ClassLoader)用来加载 java 核心类库，无法被 java 程序直接引用。  
**2. 扩展类加载器**(extensions class loader):它用来加载 Java 的扩展库。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。  
**3. 系统类加载器**（system class loader）：它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通ClassLoader.getSystemClassLoader()来获取它。  
**4. 用户自定义类加载器**，通过继承 java.lang.ClassLoader 类的方式实现。

### 15. 描述一下 JVM 加载 Class 文件的原理机制? ###

Java 语言是一种具有动态性的解释型语言，类（Class）只有被加载到 JVM 后才能运行。当运行指定程序时，JVM 会将编译生成的 .class 文件按照需求和一定的规则加载到内存中，并组织成为一个完整的 Java 应用程序。这个加载过程是由类加载器完成，具体来说，就是由 ClassLoader 和它的子类来实现的。类加载器本身也是一个类，其实质是把类文件从硬盘读取到内存中。

类的加载方式分为隐式加载和显示加载。隐式加载指的是程序在使用 new 等方式创建对象时，会隐式地调用类的加载器把对应的类加载到 JVM 中。显示加载指的是通过直接调用 class.forName()方法来把所需的类加载到 JVM 中。

任何一个工程项目都是由许多类组成的，当程序启动时，只把需要的类加载到 JVM 中，其他类只有被使用到的时候才会被加载，采用这种方法一方面可以加快加载速度，另一方面可以节约程序运行时对内存的开销。此外，在 Java 语言中，每个类或接口都对应一个 .class 文件，这些文件可以被看成是一个个可以被动态加载的单元，因此当只有部分类被修改时，只需要重新编译变化的类即可，而不需要重新编译所有文件，因此加快了编译速度。

在 Java 语言中，类的加载是动态的，它并不会一次性将所有类全部加载后再运行，而是保证程序运行的基础类（例如基类）完全加载到 JVM 中，至于其他类，则在需要的时候才加载。

**类加载的主要步骤：**

> • 装载，根据查找路径找到相应的 class 文件，然后导入。
> 
> • 链接，链接又可分为 3 个小步：
> 
> • 检查，检查待加载的 class 文件的正确性。
> 
> • 准备，给类中的静态变量分配存储空间。
> 
> • 解析，将符号引用转换为直接引用（这一步可选）
> 
> • 初始化。对静态变量和静态代码块执行初始化工作。

### 16. 说一下Java 内存分配 ###

• 寄存器：我们无法控制。

• 静态域：static 定义的静态成员。

• 常量池：编译时被确定并保存在 .class 文件中的（final）常量值和一些文本修饰的符号引用（类和接口的全限定名，字段的名称和描述符，方法和名称和描述符）。

• 非 RAM 存储：硬盘等永久存储空间。

• 堆内存：new 创建的对象和数组，由 Java 虚拟机自动垃圾回收器管理,存取速度慢。

• 栈内存：基本类型的变量和对象的引用变量（堆内存空间的访问地址），速度快，可以共享，但是大小与生存期必须确定，缺乏灵活性。

### 17.Java 堆的结构是什么样子的？什么是堆中的永久代（Perm Genspace）? ###

JVM 的堆是运行时数据区，所有类的实例和数组都是在堆上分配内存。它在 JVM 启动的时候被创建。对象所占的堆内存是由自动内存管理系统也就是垃圾收集器回收。

堆内存是由存活和死亡的对象组成的。存活的对象是应用可以访问的，不会被垃圾回收。死亡的对象是应用不可访问尚且还没有被垃圾收集器回收掉的对象。一直到垃圾收集器把这些 对象回收掉之前，他们会一直占据堆内存空间。

### 18. Java 中会存在内存泄漏吗 ###

所谓内存泄露就是指一个不再被程序使用的对象或变量一直被占据在内存中。Java 中有垃圾回收机制，它可以保证一对象不再被引用的时候，即对象变成了孤儿的时候，对象将自动被垃圾回收器从内存中清除掉。由于 Java 使用有向图的方式进行垃圾回收管理，可以消除引用循环的问题，例如有两个对象，相互引用，只要它们和根进程不可达的，那么 GC 也是可以回收它们的。

Java 中的内存泄露的情况：长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是 Java 中内存泄露的发生场景，通俗地说，就是程序员可能创建了一个对象，以后一直不再使用这个对象，这个对象却一直被引用，即这个对象无用但是却无法被垃圾回收器回收的，这就是 java中可能出现内存泄露的情况，例如，缓存系统，我们加载了一个对象放在缓存中 (例如放在一个全局 map 对象中)，然后一直不再使用它，这个对象一直被缓存引用，但却不再被使用。

检查 Java 中的内存泄露，一定要让程序将各种分支情况都完整执行到程序结束，然后看某个对象是否被使用过，如果没有，则才能判定这个对象属于内存泄露。

如果一个外部类的实例对象的方法返回了一个内部类的实例对象，这个内部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内部类持久外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄露。

内存泄露的另外一种情况：当一个对象被存储进 HashSet 集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了，否则，对象修改后的哈希值与最初存储进 HashSet 集合中时的哈希值就不同了，在这种情况下，即使在 contains 方法使用该对象的当前引用作为的参数去 HashSet 集合中检索对象，也将返回找不到对象的结果，这也会导致无法从 HashSet 集合中单独删除当前对象，造成内存泄露。

### 19. 深拷贝和浅拷贝。 ###

简单来讲就是复制、克隆。

Person p=new Person(“张三”);

浅拷贝就是对对象中的数据成员进行简单赋值，如果存在动态成员或者指针就会报错。

深拷贝就是对对象中存在的动态成员或指针重新开辟内存空间。

### 20. 说一下 JVM 调优的工具？ ###

JDK 自带了很多监控工具，都位于 JDK 的 bin 目录下，其中最常用的是 jconsole 和 jvisualvm 这两款视图监控工具。

> jconsole：用于对 JVM 中的内存、线程和类等进行监控；  
> jvisualvm：JDK 自带的全能分析工具，可以分析：内存快照、线程快照、程序死锁、监控内存的变化、gc 变化等。

###    21. 常用的 JVM 调优的参数都有哪些？ ###

>   
> \-Xms2g：初始化推大小为 2g；  
> \-Xmx2g：堆最大内存为 2g；  
> \-XX:NewRatio=4：设置年轻的和老年代的内存比例为 1:4；  
> \-XX:SurvivorRatio=8：设置新生代 Eden 和 Survivor 比例为 8:2；  
> –XX:+UseParNewGC：指定使用 ParNew + Serial Old 垃圾回收器组合；  
> \-XX:+UseParallelOldGC：指定使用 ParNew + ParNew Old 垃圾回收器组合；  
> \-XX:+UseConcMarkSweepGC：指定使用 CMS + Serial Old 垃圾回收器组合；  
> \-XX:+PrintGC：开启打印 gc 信息；  
> \-XX:+PrintGCDetails：打印 gc 详细信息。  
>

### 22. JVM中一次完整的GC流程是怎样的，对象如何晋升到老年代 ###

Java堆 = 老年代 + 新生代  
新生代 = Eden + S0 + S1  
当 Eden 区的空间满了， Java虚拟机会触发一次 Minor GC，以收集新生代的垃圾，存活下来的对象，则会转移到 Survivor区。  
大对象（需要大量连续内存空间的Java对象，如那种很长的字符串）直接进入老年态；  
如果对象在Eden出生，并经过第一次Minor GC后仍然存活，并且被Survivor容纳的话，年龄设为1，每熬过一次Minor GC，年龄+1，若年龄超过一定限制（15），则被晋升到老年态。即长期存活的对象进入老年态。  
老年代满了而无法容纳更多的对象，Minor GC 之后通常就会进行Full GC，Full GC 清理整个内存堆 – 包括年轻代和年老代。  
Major GC 发生在老年代的GC，清理老年区，经常会伴随至少一次Minor GC，比Minor GC慢10倍以上。

### 23. Minor GC、Major GC和Full GC之间的区别 ###

> 1.Minor GC  
> Minor GC指新生代GC，即发生在新生代（包括Eden区和Survivor区）的垃圾回收操作，当新生代无法为新生对象分配内存空间的时候，会触发Minor GC。因为新生代中大多数对象的生命周期都很短，所以发生Minor GC的频率很高，虽然它会触发stop-the-world，但是它的回收速度很快。
> 
> 2.Major GC  
> Major GC清理Tenured区，用于回收老年代，出现Major GC通常会出现至少一次Minor GC。
> 
> 3.Full GC  
> Full GC是针对整个新生代、老生代、元空间（metaspace，java8以上版本取代perm gen）的全局范围的GC。Full GC不等于Major GC，也不等于Minor GC+Major GC，发生Full GC需要看使用了什么垃圾收集器组合，才能解释是什么样的垃圾回收。

### 关注我们，更多技术干货： ###

**[2000多G的计算机各行业电子资源分享（持续更新）][2000_G]**

**[2020年微信小程序全栈项目之喵喵交友【附课件和源码】][2020]**

**[Spring Boot开发小而美的个人博客【附课件和源码】][Spring Boot]**

**[Java微服务实战296集大型视频-谷粒商城【附代码和课件】][Java_296_-]**

**[Java开发微服务畅购商城实战【全357集大项目】-附代码和课件][Java_357_-]**

**[最全最详细数据结构与算法视频-【附课件和源码】][-]**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70_pic_center]

[2000_G]: https://mp.weixin.qq.com/s/sP4JgGWkCzpgwKr9sAV2_Q
[2020]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487704&idx=1&sn=5f4b2127c4d49fd07ae072a0721424a2&chksm=e8036fc2df74e6d489c4aa9b06f917ef7cee6027f13e150fca53cf79d5d188d4ccc1af49e098&scene=21#wechat_redirect
[Spring Boot]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487798&idx=2&sn=ac0293b996521b872a9dba5fbb3e65e6&chksm=e8036e2cdf74e73aba104a9a994a5b2e31483e8dcbe0f1d9936f6d5173b887e1560f59d2819c&scene=21#wechat_redirect
[Java_296_-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487674&idx=1&sn=7aff0bdf2bb727303f3d3618995aef21&chksm=e8036fa0df74e6b6d872c7e6ece179c524ed463a4a6b74c96875475c9a3d5ddb903427dd993b&scene=21#wechat_redirect
[Java_357_-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247486376&idx=1&sn=d1fef270c463ea8ac663f6fbfedd70a0&chksm=e80374b2df74fda4d3bafba878a106a19e18c5fcda266008f4f37975847a21bc612ffcd5ff39&scene=21#wechat_redirect
[-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487750&idx=1&sn=747bccbb5f5ea6b58915198de40da777&chksm=e8036e1cdf74e70ae97a5e8e265b49d7236d904d291203309159d07ba1724033062c0e370843&scene=21#wechat_redirect
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70_pic_center]: /images/20221022/1af7ef4e9ceb45a99aebe82343627d39.png
[6bf166bb47f6d1a12521f31de5be3b22.png]: /images/20221022/07d61a9e7d774446a544be6a3e9bb0bb.png
[2acd352359aed98f186978c123e6ba1d.png]: /images/20221022/0413405f0b8e4bc791b457f0ab150e29.png
[1004ba9105b4a1601e17a86ba756759d.png]: /images/20221022/72f350b6e8724b22a863800b33bd032c.png
[28606ae43740f6b551c1c9ce6835ec10.png]: /images/20221022/2ab5d08d02634493b09206ad06129115.png
[bbbfec93ae9468e8b2efb98dc00b208f.png]: /images/20221022/36463aeff12d45ea8c5b2666ff60bc1f.png
[78546941d610c58b503fee33d48682fb.png]: /images/20221022/13792bd9b2914855a3910aa4acae51db.png
[34388a554163ee17d23a2fea18635379.png]: /images/20221022/8064ae85d86e43ef9624cbcd79a47ef9.png
[20b2845b5a2b176525721044f7f30193.png]: /images/20221022/5b9a7f0f98f6449ebedcf9f38c1aae03.png