java面试必备--JVM篇（三）

        相信很多同行小伙伴会因为许多原因想跳槽，不论是干得不开心还是想跳槽涨薪，在如此内卷的行业，我们都面临着“面试造火箭，上班拧螺丝”的局面，鉴于当前形势博主呕心沥血整理的干货满满的造火箭的技巧来了，本博主花费2个月时间，整理归纳java全生态知识体系常见面试题！总字数高达百万！ 干货满满，每天更新，关注我，不迷路，用强大的归纳总结，全新全细致的讲解来留住各位猿友的关注，希望能够帮助各位猿友在应付面试笔试上！当然如有归纳总结错误之处请各位指出修正！如有侵权请联系博主QQ1062141499!
 

---

目录

1 说一下 JVM 有哪些垃圾回收器？

2 JVM运行时数据区

3 简单介绍下Java中垃圾回收机制

4 Java中类加载过程是什么样的？

5 JVM 有哪些垃圾回收算法？

6 类装载的执行过程

7 对象创建过程是什么样的？

8 什么是Java的垃圾回收机制？

9 Java跨平台运行的原理

10 Java的安全性体现在哪里？

11 Java针对不同的应用场景提供了哪些版本？

12 JVM的主要组成部分？及其作用？

13 堆和栈区别

14 队列和栈区别

15 Java的类加载器的种类都有哪些？

16 类什么时候被初始化？

17 什么是双亲委派模型？

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

19 Java 中都有哪些引用类型？

20 详细介绍一下 CMS 垃圾回收器？

21 简述分代垃圾回收器是怎么工作的？

22 说一下 JVM 调优的工具？

23 既然有GC机制，为什么还会有内存泄露的情况

24 获得一个类对象有哪些方式

25 Java中为什么会有GC机制呢？

26 对于Java的GC哪些内存需要回收

27 Java的GC什么时候回收垃圾

28 在开发中遇到过内存溢出么？原因有哪些？解决方法有哪些？

29 内存泄漏和内存溢出的区别

---

1 说一下 JVM 有哪些垃圾回收器？

•       Serial：最早的单线程串行垃圾回收器。

•       Serial Old：Serial 垃圾回收器的老年版本，同样也是单线程的，可以作为 CMS 垃圾回收器的备选预案。

•       ParNew：是 Serial 的多线程版本。

•       Parallel Scavenge 和 ParNew 收集器类似是多线程的，但 Parallel Scavenge是吞吐量优先的收集器，可以牺牲等待时间换取系统的吞吐量。

•       Parallel Old 是 Parallel 老生代版本，Parallel 使用的是复制的内存回收算法，Parallel Old 使用的是标记-整理的内存回收算法。

•       CMS：一种以获得最短停顿时间为目标的收集器，非常适用 B/S 系统。

•       G1：一种兼顾吞吐量和停顿时间的 GC 实现，是 JDK 9 以后的默认 GC 选项。

2 JVM运行时数据区

      不同虚拟机的运行时数据区可能略微有所不同，但都会遵从 Java 虚拟机规范， Java 虚拟机规范规定的区域分为以下 5 个部分：

•       程序计数器（Program Counter Register）：当前线程所执行的字节码的行号指示器，字节码解析器的工作是通过改变这个计数器的值，来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能，都需要依赖这个计数器来完成；

•       Java 虚拟机栈（Java Virtual Machine Stacks）：用于存储局部变量表、操作数栈、动态链接、方法出口等信息；栈是运行时创建的，是线程私有的，生命周期与线程相同，存储声明的变量

•       本地方法栈（Native Method Stack）：与虚拟机栈的作用是一样的，只不过虚拟机栈是服务 Java 方法的，而本地方法栈是为虚拟机调用 Native方法服务的；native 方法是一种由非 java 语言实现的 java 方法，与 java 环境外交互，如可以用本地方法与操作系统交互

•       Java堆（Java Heap）：Java 虚拟机中内存最大的一块，是被所有线程共享的，几乎所有的对象实例都在这里分配内存；所以经常发生垃圾回收操作

•       方法区（Methed Area）：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译后的代码等数据。该区域是被线程共享的，很少发生垃圾回收

3 简单介绍下Java中垃圾回收机制

    什么样的对象会被当做垃圾回收？

      当一个对象的地址没有变量去引用时，该对象就会成为垃圾对象，垃圾回收器在空闲的时候会对其进行内存清理回收

   如何检验对象是否被回收？

     可以重写 Object 类中的 finalize 方法，这个方法在垃圾收集器执行的时候，被收集器自动调用执行的

   怎样通知垃圾收集器回收对象？

     可以调用 System 类的静态方法 gc()，通知垃圾收集器去清理垃圾，但不能保证收集动作立即执行，具体的执行时间取决于垃圾收集的算法

4 Java中类加载过程是什么样的？

     类加载的步骤为，加载 -> 验证 -> 准备 -> 解析 -> 初始化。

 1、加载：

• 获取类的二进制字节流
• 将字节流代表的静态存储结构转化为方法区运行时数据结构
• 在堆中生成class字节码对象

 2、验证：连接过程的第一步，确保 class 文件的字节流中的信息符合当前 JVM 的要求，不会危害 JVM 的安全

 3、准备：为类的静态变量分配内存并将其初始化为默认值

 4、解析：JVM 将常量池内符号引用替换成直接引用的过程

 5、初始化：执行类构造器的初始化的过程

5 JVM 有哪些垃圾回收算法？

  标记-清除算法：

       标记无用对象，然后进行清除回收。缺点：效率不高，无法清除垃圾碎片。

       标记—清除算法包括两个阶段：“标记”和“清除”。在标记阶段，确定所有要回收的对象，并做标记。清除阶段紧随标记阶段，将标记阶段确定不可用的对象清除。标记—清除算法是基础的收集算法，标记和清除阶段的效率不高，而且清除后回产生大量的不连续空间，这样当程序需要分配大内存对象时，可能无法找到足够的连续空间。

标记-整理算法：

      标记无用对象，让所有存活的对象都向一端移动，然后直接清除掉端边界以外的内存。标记—整理算法和标记—清除算法一样，但是标记—整理算法不是把存活对象复制到另一块内存，而是把存活对象往内存的一端移动，然后直接回收边界以外的内存。标记—整理算法提高了内存的利用率，并且它适合在收集对象存活时间较长的老年代。

复制算法：

       按照容量划分二个大小相等的内存区域，当一块用完的时候将活着的对象复制到另一块上，然后再把已使用的内存空间一次清理掉。缺点：内存使用率不高，只有原来的一半。

       复制算法是把内存分成大小相等的两块，每次使用其中一块，当垃圾回收的时候，把存活的对象复制到另一块上，然后把这块内存整个清理掉。复制算法实现简单，运行效率高，但是由于每次只能使用其中的一半，造成内存的利用率不高。现在的 JVM 用复制方法收集新生代，由于新生代中大部分对象（98%）都是朝生夕死的，所以两块内存的比例不是 1:1(大概是 8:1)。

 

分代算法：

      根据对象存活周期的不同将内存划分为几块，一般是新生代和老年代，新生代基本采用复制算法，老年代采用标记整理算法。

        分代收集是根据对象的存活时间把内存分为新生代和老年代，根据各个代对象的存活特点，每个代采用不同的垃圾回收算法。新生代采用复制算法，老年代采用标记—整理算法。垃圾算法的实现涉及大量的程序细节，而且不同的虚拟机平台实现的方法也各不相同。

标记清除算法

步骤很简单

1. 先根据可达性算法标记出相应的可回收对象（图中黄色部分）
2. 对可回收的对象进行回收操作起来确实很简单，也不用做移动数据的操作，那有啥问题呢？仔细看上图，没错，内存碎片！假如我们想在上图中的堆中分配一块需要连续内存占用 4M 或 5M 的区域，显然是会失败，怎么解决呢，如果能把上面未使用的 2M， 2M，1M 内存能连起来就能连成一片可用空间为 5M 的区域即可，怎么做呢?

复制算法

       把堆等分成两块区域, A 和 B，区域 A 负责分配对象，区域 B 不分配, 对区域 A 使用以上所说的标记法把存活的对象标记出来（下图有误无需清除），然后把区域 A 中存活的对象都复制到区域 B（存活对象都依次紧邻排列）最后把 A 区对象全部清理掉释放出空间，这样就解决了内存碎片的问题了。

      不过复制算法的缺点很明显，比如给堆分配了 500M 内存，结果只有 250M 可用，空间平白无故减少了一半！这肯定是不能接受的！另外每次回收也要把存活对象移动到另一半，效率低下（我们可以想想删除数组元素再把非删除的元素往一端移，效率显然堪忧）

标记整理法

      前面两步和标记清除法一样，不同的是它在标记清除法的基础上添加了一个整理的过程 ，即将所有的存活对象都往一端移动,紧邻排列（如图示），再清理掉另一端的所有区域，这样的话就解决了内存碎片的问题。

 

但是缺点也很明显：每进一次垃圾清除都要频繁地移动存活的对象，效率十分低下。

分代收集算法

       分代收集算法整合了以上算法，综合了这些算法的优点，最大程度避免了它们的缺点，所以是现代虚拟机采用的首选算法,与其说它是算法，倒不是说它是一种策略，因为它是把上述几种算法整合在了一起，为啥需要分代收集呢，来看一下对象的分配有啥规律。

如图示：纵轴代表已分配的字节，而横轴代表程序运行时间

      由图可知，大部分的对象都很短命，都在很短的时间内都被回收了（IBM 专业研究表明，一般来说，98% 的对象都是朝生夕死的，经过一次 Minor GC 后就会被回收），所以分代收集算法根据对象存活周期的不同将堆分成新生代和老生代（Java8以前还有个永久代）,默认比例为 1 : 2，新生代又分为 Eden 区， from Survivor 区（简称S0），to Survivor 区(简称 S1),三者的比例为 8: 1 : 1，这样就可以根据新老生代的特点选择最合适的垃圾回收算法，我们把新生代发生的 GC 称为 Young GC（也叫 Minor GC）,老年代发生的 GC 称为 Old GC（也称为 Full GC）。

 

 

画外音：思考一下，新生代为啥要分这么多区？

那么分代垃圾收集是怎么工作的呢，我们一起来看看

分代收集工作原理

  1、对象在新生代的分配与回收

由以上的分析可知，大部分对象在很短的时间内都会被回收，对象一般分配在 Eden 区

 

当 Eden 区将满时，触发 Minor GC

 

      我们之前怎么说来着，大部分对象在短时间内都会被回收, 所以经过 Minor GC 后只有少部分对象会存活，它们会被移到 S0 区（这就是为啥空间大小 Eden: S0: S1 = 8:1:1, Eden 区远大于 S0,S1 的原因，因为在 Eden 区触发的 Minor GC 把大部对象（接近98%）都回收了,只留下少量存活的对象，此时把它们移到 S0 或 S1 绰绰有余）同时对象年龄加一（对象的年龄即发生 Minor GC 的次数），最后把 Eden 区对象全部清理以释放出空间,动图如下

       当触发下一次 Minor GC 时，会把 Eden 区的存活对象和 S0（或S1） 中的存活对象（S0 或 S1 中的存活对象经过每次 Minor GC 都可能被回收）一起移到 S1（Eden 和 S0 的存活对象年龄+1）, 同时清空 Eden 和 S0 的空间。

      若再触发下一次 Minor GC，则重复上一步，只不过此时变成了 从 Eden，S1 区将存活对象复制到 S0 区,每次垃圾回收, S0, S1 角色互换，都是从 Eden ,S0(或S1) 将存活对象移动到 S1(或S0)。也就是说在 Eden 区的垃圾回收我们采用的是复制算法，因为在 Eden 区分配的对象大部分在 Minor GC 后都消亡了，只剩下极少部分存活对象（这也是为啥 Eden:S0:S1 默认为 8:1:1 的原因），S0,S1 区域也比较小，所以最大限度地降低了复制算法造成的对象频繁拷贝带来的开销。

2、对象何时晋升老年代

• 当对象的年龄达到了我们设定的阈值，则会从S0（或S1）晋升到老年代如图示：年龄阈值设置为 15， 当发生下一次 Minor GC 时，S0 中有个对象年龄达到 15，达到我们的设定阈值，晋升到老年代！
• 大对象 当某个对象分配需要大量的连续内存时，此时对象的创建不会分配在 Eden 区，会直接分配在老年代，因为如果把大对象分配在 Eden 区, Minor GC 后再移动到 S0,S1 会有很大的开销（对象比较大，复制会比较慢，也占空间），也很快会占满 S0,S1 区，所以干脆就直接移到老年代。
• 还有一种情况也会让对象晋升到老年代，即在 S0（或S1） 区相同年龄的对象大小之和大于 S0（或S1）空间一半以上时，则年龄大于等于该年龄的对象也会晋升到老年代。

3、空间分配担保

      在发生 MinorGC 之前，虚拟机会先检查老年代最大可用的连续空间是否大于新生代所有对象的总空间，如果大于，那么Minor GC 可以确保是安全的,如果不大于，那么虚拟机会查看 HandlePromotionFailure 设置值是否允许担保失败。如果允许，那么会继续检查老年代最大可用连续空间是否大于历次晋升到老年代对象的平均大小，如果大于则进行 Minor GC，否则可能进行一次 Full GC。

4、Stop The World

        如果老年代满了，会触发 Full GC, Full GC 会同时回收新生代和老年代（即对整个堆进行GC），它会导致 Stop The World（简称 STW）,造成挺大的性能开销。

      什么是 STW ？所谓的 STW, 即在 GC（minor GC 或 Full GC）期间，只有垃圾回收器线程在工作，其他工作线程则被挂起。

 

      画外音：为啥在垃圾收集期间其他工作线程会被挂起？想象一下，你一边在收垃圾，另外一群人一边丢垃圾，垃圾能收拾干净吗。

       一般 Full GC 会导致工作线程停顿时间过长（因为Full GC 会清理整个堆中的不可用对象，一般要花较长的时间），如果在此 server 收到了很多请求，则会被拒绝服务！所以我们要尽量减少 Full GC（Minor GC 也会造成 STW,但只会触发轻微的 STW,因为 Eden 区的对象大部分都被回收了，只有极少数存活对象会通过复制算法转移到 S0 或 S1 区，所以相对还好）。

      现在我们应该明白把新生代设置成 Eden, S0，S1区或者给对象设置年龄阈值或者默认把新生代与老年代的空间大小设置成 1:2 都是为了尽可能地避免对象过早地进入老年代，尽可能晚地触发 Full GC。想想新生代如果只设置 Eden 会发生什么，后果就是每经过一次 Minor GC，存活对象会过早地进入老年代，那么老年代很快就会装满，很快会触发 Full GC，而对象其实在经过两三次的 Minor GC 后大部分都会消亡，所以有了 S0,S1的缓冲，只有少数的对象会进入老年代，老年代大小也就不会这么快地增长，也就避免了过早地触发 Full GC。

      由于 Full GC（或Minor GC） 会影响性能，所以我们要在一个合适的时间点发起 GC，这个时间点被称为 Safe Point，这个时间点的选定既不能太少以让 GC 时间太长导致程序过长时间卡顿，也不能过于频繁以至于过分增大运行时的负荷。一般当线程在这个时间点上状态是可以确定的，如确定 GC Root 的信息等，可以使 JVM 开始安全地 GC。Safe Point 主要指的是以下特定位置：

• 循环的末尾
• 方法返回前
• 调用方法的 call 之后
• 抛出异常的位置 另外需要注意的是由于新生代的特点（大部分对象经过 Minor GC后会消亡）， Minor GC 用的是复制算法，而在老生代由于对象比较多，占用的空间较大，使用复制算法会有较大开销（复制算法在对象存活率较高时要进行多次复制操作，同时浪费一半空间）所以根据老生代特点，在老年代进行的 GC 一般采用的是标记整理法来进行回收。

 

6 类装载的执行过程

类装载分为以下 5 个步骤：

•       加载：根据查找路径找到相应的 class 文件然后导入；

•       检查：检查加载的 class 文件的正确性；

•       准备：给类中的静态变量分配内存空间；

•       解析：虚拟机将常量池中的符号引用替换成直接引用的过程。符号引用就理解为一个标示，而在直接引用直接指向内存中的地址；

•       初始化：对静态变量和静态代码块执行初始化工作。

      JVM 中类的装载是由类加载器（ClassLoader）和它的子类来实现的，Java  中的类加载器是一个重要的 Java 运行时系统组件，它负责在运行时查找和装入类文件中的类。

      由于 Java 的跨平台性，经过编译的  Java  源程序并不是一个可执行程序，而是一个或多个类文件。当 Java  程序需要使用某个类时,JVM  会确保这个类已经被加载、连接（验证、准备和解析）和初始化。类的加载是指把类的.class文件中的数据读入到内存中，通常是创建一个字节数组读入.class  文件，然后产生与所加载类对应的 Class  对象。加载完成后，Class  对象还不完整，所以此时的类还不可用。当类被加载后就进入连接阶段，这一阶段包括验证、准备（为静态变量分配内存并设置默认的初始值）和解析（将符号引用替换为直接引用）三个步骤。最后  JVM  对类进行初始化，包括：

      如果类存在直接的父类并且这个类还没有被初始化，那么就先初始化父类；如果类中存在初始化语句，就依次执行这些初始化语句。类的加载是由类加载器完成的，类加载器包括：根加载器（BootStrap）、扩展加载器（Extension）、系统加载器（System）和用户自定义类加载器（java.lang.ClassLoader的子类）。

       从  Java 2（JDK 1.2）开始，类加载过程采取了父亲委托机制（PDM）。PDM  更好的保证了  Java 平台的安全性，在该机制中，JVM  自带的 Bootstrap  是根加载器，其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。JVM 不会向 Java 程序提供对  Bootstrap  的引用。

下面是关于几个类加载器的说明：

•   Bootstrap：一般用本地代码实现，负责加载  JVM  基础核心类库（rt.jar）；

•   Extension：从  java.ext.dirs  系统属性所指定的目录中加载类库，它的父加载器是 Bootstrap；

•   System：又叫应用类加载器，其父类是  Extension。它是应用最广泛的类加载器。它从环境变量  classpath

或者系统属性  java.class.path 所指定的目录中记载类，是用户自定义加载器的默认父加载器。

7 对象创建过程是什么样的？

对象在 JVM 中的创建过程如下：

• JVM 会先去方法区找有没有所创建对象的类存在，有就可以创建对象了，没有则把该类加载到方法区
• 在创建类的对象时，首先会先去堆内存中分配空间
• 当空间分配完后，加载对象中所有的非静态成员变量到该空间下
• 所有的非静态成员变量加载完成之后，对所有的非静态成员进行默认初始化
• 所有的非静态成员默认初始化完成之后，调用相应的构造方法到栈中
• 在栈中执行构造函数时，先执行隐式，再执行构造方法中书写的代码
• 执行顺序：静态代码库，构造代码块，构造方法
• 当整个构造方法全部执行完，此对象创建完成，并把堆内存中分配的空间地址赋给对象名

8 什么是Java的垃圾回收机制？

垃圾回收机制，简称 GC

1. Java 语言不需要程序员直接控制内存回收，由 JVM 在后台自动回收不再使用的内存
2. 提高编程效率
3. 保护程序的完整性
4. JVM 需要跟踪程序中有用的对象，确定哪些是无用的，影响性能

特点

1. 回收 JVM 堆内存里的对象空间，不负责回收栈内存数据
2. 无法处理一些操作系统资源的释放，如数据库连接、输入流输出流、Socket 连接
3. 垃圾回收发生具有不可预知性，程序无法精确控制垃圾回收机制执行
4. 可以将对象的引用变量设置为 null，垃圾回收机制可以在下次执行时回收该对象。
5. JVM 有多种垃圾回收 实现算法，表现各异
6. 垃圾回收机制回收任何对象之前，会先调用对象的 finalize() 方法
7. 可以通过 System.gc() 或 Runtime.getRuntime().gc() 通知系统进行垃圾回收，会有一些效果，但系统是否进行垃圾回收依然不确定
8. 不要主动调用对象的 finalize() 方法，应该交给垃圾回收机制调用

9 Java跨平台运行的原理

      1、.java 源文件要先编译成与操作系统无关的 .class 字节码文件，然后字节码文件再通过 Java 虚拟机解释成机器码运行。

      2、.class 字节码文件面向虚拟机，不面向任何具体操作系统。

      3、不同平台的虚拟机是不同的，但它们给 JDK 提供了相同的接口。

      4、Java 的跨平台依赖于不同系统的 Java 虚拟机。

10 Java的安全性体现在哪里？

     1、使用引用取代了指针，指针的功能强大，但是也容易造成错误，如数组越界问题。

     2、拥有一套异常处理机制，使用关键字 throw、throws、try、catch、finally

     3、强制类型转换需要符合一定规则

     4、字节码传输使用了加密机制

     5、运行环境提供保障机制：字节码校验器->类装载器->运行时内存布局->文件访问限制

     6、不用程序员显示控制内存释放，JVM 有垃圾回收机制

11 Java针对不同的应用场景提供了哪些版本？

      J2SE：Standard Edition(标准版) ，包含 Java 语言的核心类。如IO、JDBC、工具类、网络编程相关类等。从JDK 5.0开始，改名为Java SE。

      J2EE：Enterprise Edition(企业版)，包含 J2SE 中的类和企业级应用开发的类。如web相关的servlet类、JSP、xml生成与解析的类等。从JDK 5.0开始，改名为Java EE。

      J2ME：Micro Edition(微型版)，包含 J2SE 中的部分类，新添加了一些专有类。一般用设备的嵌入式开发，如手机、机顶盒等。从JDK 5.0开始，改名为Java ME。

12 JVM的主要组成部分？及其作用？

•       类加载器（ClassLoader）

•       运行时数据区（Runtime Data Area）

•       执行引擎（Execution Engine）

•       本地库接口（Native Interface）

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

 

13 堆和栈区别

•       功能方面：堆是用来存放对象的，栈是用来执行程序的。

•       共享性：堆是线程共享的，栈是线程私有的。

•       空间大小：堆大小远远大于栈 

14 队列和栈区别

     队列和栈都是被用来预存储数据的。

     队列允许先进先出检索元素，但也有例外的情况，Deque 接口允许从两端检索元素。

     栈和队列很相似，但它运行对元素进行后进先出进行检索。

15 Java的类加载器的种类都有哪些？

      1、根类加载器(Bootstrap) --C++写的  ，看不到源码

      2、扩展类加载器（Extension）  --加载位置 ：jre\lib\ext中

      3、系统(应用)类加载器(System\App)   --加载位置  ：classpath  中

       4、自定义加载器(必须继承  ClassLoader)

16 类什么时候被初始化？

       1）创建类的实例，也就是 new一个对象

       2）访问某个类或接口的静态变量，或者对该静态变量赋值

       3）调用类的静态方法

       4）反射（Class.forName("com.lyj.load")）

       5）初始化一个类的子类（会首先初始化子类的父类）

       6）JVM启动时标明的启动类，即文件名和类名相同的那个类

只有这 6  中情况才会导致类的类的初始化。

类的初始化步骤：

       1）如果这个类还没有被加载和链接，那先进行加载和链接

       2）假如这个类存在直接父类，并且这个类还没有被初始化（注意：在一个类加载器中，类只能初始化一次），那就初始化直接的父类（不适用于接口）

       3)加入类中存在初始化语句（如 static 变量和 static  块），那就依次执行这些初始化语句。

17 什么是双亲委派模型？

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

类加载器分类：

•       启动类加载器（Bootstrap ClassLoader），是虚拟机自身的一部分，用来加载Java_HOME/lib/目录中的，或者被 -Xbootclasspath 参数所指定的路径中并且被虚拟机识别的类库；

•       其他类加载器：

•       扩展类加载器（Extension ClassLoader）：负责加载\lib\ext目录或Java. ext. dirs系统变量指定的路径中的所有类库；

•       应用程序类加载器（Application ClassLoader）。负责加载用户类路径（classpath）上的指定类库，我们可以直接使用这个类加载器。一般情况，如果我们没有自定义类加载器默认就是用这个加载器。

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

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

一般有两种方法来判断：

•       引用计数器（废弃）：为每个对象创建一个引用计数，有对象引用时计数器 +1，引用被释放时计数 -1，当计数器为 0 时就可以被回收。它有一个缺点不能解决循环引用的问题；

•       可达性分析：从 GC Roots 开始向下搜索，搜索所走过的路径称为引用链。当一个对象到 GC Roots 没有任何引用链相连时，则证明此对象是可以被回收的。

19 Java 中都有哪些引用类型？

•       强引用：发生 gc 的时候不会被回收。

•       软引用：有用但不是必须的对象，在发生内存溢出之前会被回收。

•       弱引用：有用但不是必须的对象，在下一次GC时会被回收。

•       虚引用（幽灵引用/幻影引用）：无法通过虚引用获得对象，用 PhantomReference 实现虚引用，虚引用的用途是在 gc 时返回一个通知。

Java的四种引用，强弱软虚，用到的场景

从JDK1.2版本开始，把对象的引用分为四种级别，从而使程序能更加灵活的控制对象的生命周期。这四种级别由高到低依次为：强引用、软引用、弱引用和虚引用。

1、强引用

      最普遍的一种引用方式，如String s = "abc"，变量s就是字符串“abc”的强引用，只要强引用存在，则垃圾回收器就不会回收这个对象。

2、软引用（SoftReference）

       用于描述还有用但非必须的对象，如果内存足够，不回收，如果内存不足，则回收。一般用于实现内存敏感的高速缓存，软引用可以和引用队列ReferenceQueue联合使用，如果软引用的对象被垃圾回收，JVM就会把这个软引用加入到与之关联的引用队列中。

3、弱引用（WeakReference）

       弱引用和软引用大致相同，弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。

4、虚引用（PhantomReference）

        就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。 虚引用主要用来跟踪对象被垃圾回收器回收的活动。

虚引用与软引用和弱引用的一个区别在于：

      虚引用必须和引用队列 （ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。

20 详细介绍一下 CMS 垃圾回收器？

       CMS 是英文 Concurrent Mark-Sweep 的简称，是以牺牲吞吐量为代价来获得最短回收停顿时间的垃圾回收器。对于要求服务器响应速度的应用上，这种垃圾回收器非常适合。在启动 JVM 的参数加上“-XX:+UseConcMarkSweepGC”来指定使用 CMS 垃圾回收器。

      CMS 使用的是标记-清除的算法实现的，所以在 gc 的时候回产生大量的内存碎片，当剩余内存不能满足程序运行要求时，系统将会出现 Concurrent Mode Failure，临时 CMS 会采用 Serial Old 回收器进行垃圾清除，此时的性能将会被降低。

21 简述分代垃圾回收器是怎么工作的？

      分代回收器有两个分区：老生代和新生代，新生代默认的空间占比总空间的 1/3，老生代的默认占比是 2/3。

       新生代使用的是复制算法，新生代里有 3 个分区：Eden、To Survivor、From Survivor，它们的默认占比是 8:1:1，它的执行流程如下：

•       把 Eden + From Survivor 存活的对象放入 To Survivor 区；

•       清空 Eden 和 From Survivor 分区；

•       From Survivor 和 To Survivor 分区交换，From Survivor 变 To Survivor，To Survivor 变 From Survivor。

     每次在 From Survivor 到 To Survivor 移动时都存活的对象，年龄就 +1，当年龄到达 15（默认配置是 15）时，升级为老生代。大对象也会直接进入老生代。

       老生代当空间占用到达某个值之后就会触发全局垃圾收回，一般使用标记整理的执行算法。以上这些循环往复就构成了整个分代垃圾回收的整体执行流程。

22 说一下 JVM 调优的工具？

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

•       jconsole：用于对 JVM 中的内存、线程和类等进行监控；

•       jvisualvm：JDK 自带的全能分析工具，可以分析：内存快照、线程快照、程序死锁、监控内存的变化、gc 变化等。

1. 常用的 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 详细信息。

23 既然有GC机制，为什么还会有内存泄露的情况

        理论上 Java 因为有垃圾回收机制（GC）不会存在内存泄露问题（这也是 Java 被广泛使用于服务器端编程的一个重要原因）。然而在实际开发中，可能会存在无用但可达的对象，这些对象不能被 GC 回收，因此也会导致内存泄露的发生。

        例如 hibernate 的 Session（一级缓存）中的对象属于持久态，垃圾回收器是不会回收这些对象的，然而这些对象中可能存在无用的垃圾对象，如果不及时关闭（close）或清空（flush）一级缓存就可能导致内存泄露。

下面例子中的代码也会导致内存泄露。

import java.util.Arrays;
import java.util.EmptyStackException;
public class MyStack<T> {
    private T[] elements;
    private int size = 0;
    private static final int INIT_CAPACITY = 16;
    public MyStack() {
        elements = (T[]) new Object[INIT_CAPACITY];
    }
    public void push(T elem) {
        ensureCapacity();
        elements[size++] = elem;
    }
    public T pop() {
        if (size == 0) throw new EmptyStackException();
        return elements[--size];
    }
    private void ensureCapacity() {
        if (elements.length == size) {
            elements = Arrays.copyOf(elements, 2 * size + 1);
        }
    }
}

 

       上面的代码实现了一个栈（先进后出（FILO））结构，乍看之下似乎没有什么明显的问题，它甚至可以通过你编写的各种单元测试。然而其中的 pop 方法却存在内存泄露的问题，当我们用 pop 方法弹出栈中的对象时，该对象不会被当作垃圾回收，即使使用栈的程序不再引用这些对象，因为栈内部维护着对这些对象的过期引用（obsolete reference）。在支持垃圾回收的语言中，内存泄露是很隐蔽的，这种内存泄露其实就是无意识的对象保持。如果一个对象引用被无意识的保留起来了，那么垃圾回收器不会处理这个对象，也不会处理该对象引用的其他对象，即使这样的对象只有少数几个，也可能会导致很多的对象被排除在垃圾回收之外，从而对性能造成重大影响，极端情况下会引发 Disk Paging （物理内存与硬盘的虚拟内存交换数据），甚至造成 OutOfMemoryError。

24 获得一个类对象有哪些方式

      类型.class，例如：String.class

      对象.getClass()，例如：”hello”.getClass()

      Class.forName()，例如：Class.forName(“java.lang.String”)

25 Java中为什么会有GC机制呢？

         安全性考虑；-- for  security.

          减少内存泄露；-- erase  memory leak  in some degree.

          减少程序员工作量。-- Programmers  don't worry  about memory releasing.

26 对于Java的GC哪些内存需要回收

         内存运行时JVM会有一个运行时数据区来管理内存。它主要包括5大部分：程序计数器(ProgramCounterRegister)、虚拟机栈(VMStack)、本地方法栈(NativeMethodStack)、方法区(MethodArea)、堆(Heap).而其中程序计数器、虚拟机栈、本地方法栈是每个线程私有的内存空间，随线程而生，随线程而亡。例如栈中每一个栈帧中分配多少内存基本上在类结构确定是哪个时就已知了，因此这3个区域的内存分配和回收都是确定的，无需考虑内存回收的问题。

但方法区和堆就不同了，一个接口的多个实现类需要的内存可能不一样，我们只有在程序运行期间才会知道会创建哪些对象，这部分内存的分配和回收都是动态的，GC主要关注的是这部分内存。

总而言之，GC主要进行回收的内存是JVM中的方法区和堆；

27 Java的GC什么时候回收垃圾

        在面试中经常会碰到这样一个问题（事实上笔者也碰到过）：如何判断一个对象已经死去？

        很容易想到的一个答案是：对一个对象添加引用计数器。每当有地方引用它时，计数器值加1；当引用失效时，计数器值减1.而当计数器的值为0时这个对象就不会再被使用，判断为已死。是不是简单又直观。然而，很遗憾。这种做法是错误的！为什么是错的呢？事实上，用引用计数法确实在大部分情况下是一个不错的解决方案，而在实际的应用中也有不少案例，但它却无法解决对象之间的循环引用问题。比如对象A中有一个字段指向了对象B，而对象B中也有一个字段指向了对象A，而事实上他们俩都不再使用，但计数器的值永远都不可能为0，也就不会被回收，然后就发生了内存泄露。

所以，正确的做法应该是怎样呢？

      在Java，C#等语言中，比较主流的判定一个对象已死的方法是：可达性分析(ReachabilityAnalysis).所有生成的对象都是一个称为"GCRoots"的根的子树。从GCRoots开始向下搜索，搜索所经过的路径称为引用链(ReferenceChain)，当一个对象到GCRoots没有任何引用链可以到达时，就称这个对象是不可达的（不可引用的），也就是可以被GC回收了。

      无论是引用计数器还是可达性分析，判定对象是否存活都与引用有关！那么，如何定义对象的引用呢？

      我们希望给出这样一类描述：当内存空间还够时，能够保存在内存中；如果进行了垃圾回收之后内存空间仍旧非常紧张，则可以抛弃这些对象。所以根据不同的需求，给出如下四种引用，根据引用类型的不同，GC回收时也会有不同的操作：

      1)强引用(StrongReference):Objectobj=newObject();只要强引用还存在，GC永远不会回收掉被引用的对象。

     2)软引用(SoftReference)：描述一些还有用但非必需的对象。在系统将会发生内存溢出之前，会把这些对象列入回收范围进行二次回收（即系统将会发生内存溢出了，才会对他们进行回收。）

      弱引用(WeakReference):程度比软引用还要弱一些。这些对象只能生存到下次GC之前。当GC工作时，无论内存是否足够都会将其回收（即只要进行GC，就会对他们进行回收。）

       虚引用(PhantomReference):一个对象是否存在虚引用，完全不会对其生存时间构成影响。

关于方法区中需要回收的是一些废弃的常量和无用的类。

      1.废弃的常量的回收。这里看引用计数就可以了。没有对象引用该常量就可以放心的回收了。

      2.无用的类的回收。什么是无用的类呢？

      A.该类所有的实例都已经被回收。也就是Java堆中不存在该类的任何实例；

      B.加载该类的ClassLoader已经被回收；

      C.该类对应的java.lang.Class对象没有任何地方被引用，无法在任何地方通过反射访问该类的方法。

总而言之:

        对于堆中的对象，主要用可达性分析判断一个对象是否还存在引用，如果该对象没有任何引用就应该被回收。而根据我们实际对引用的不同需求，又分成了4中引用，每种引用的回收机制也是不同的。

       对于方法区中的常量和类，当一个常量没有任何对象引用它，它就可以被回收了。而对于类，如果可以判定它为无用类，就可以被回收了。

28 在开发中遇到过内存溢出么？原因有哪些？解决方法有哪些？

引起内存溢出的原因有很多种，常见的有以下几种：

     1.内存中加载的数据量过于庞大，如一次从数据库取出过多数据；

     2.集合类中有对对象的引用，使用完后未清空，使得 JVM  不能回收；

     3.代码中存在死循环或循环产生过多重复的对象实体；

     4.使用的第三方软件中的 BUG；

     5.启动参数内存值设定的过小；

内存溢出的解决方案：

     第一步，修改 JVM 启动参数，直接增加内存。(-Xms，-Xmx 参数一定不要忘记加。)

     第二步，检查错误日志，查看“OutOfMemory”错误前是否有其它异常或错误。

     第三步，对代码进行走查和分析，找出可能发生内存溢出的位置。

重点排查以下几点：

      1 检查对数据库查询中，是否有一次获得全部数据的查询。一般来说，如果一次取十万条记录到内存，就可能引起内存溢出。这个问题比较隐蔽，在上线前，数据库中数据较少，不容易出问题，上线后，数据库中数据多了，一次查询就有可能引起内存溢出。因此对于数据库查询尽量采用分页的方式查询。

     2 检查代码中是否有死循环或递归调用。

     3 检查是否有大循环重复产生新对象实体。

     4检查 List、MAP 等集合对象是否有使用完后，未清除的问题。List、MAP  等集合对象会始终存有对对象的引用，使得这些对象不能被 GC  回收。

    第四步，使用内存查看工具动态查看内存使用情况。

1. 方法区内存溢出怎么处理？

在 Java 虚拟机中，方法区是可供各线程共享的运行时内存区域。

在不同的 JDK 版本中，方法区中存储的数据是不一样的：

• JDK 1.7 之前的版本，运行时常量池是方法区的一个部分，同时方法区里面存储了类的元数据信息、静态变量、即时编译器编译后的代码等。
• JDK 1.7 开始，JVM 已经将运行时常量池从方法区中移了出来，在 JVM 开辟了一块区域存放常量池。

       永久代就是 HotSpot 版的 Java 虚拟机对虚拟机规范中方法区的一种实现方式，永久代和方法区的关系就像 Java 中类和接口的关系。

       HotSpot 版的 Java 虚拟机在 JDK 1.8 之后取消了永久代，改为元空间，类的元信息被存储在元空间中。元空间没有使用堆内存，而是与堆不相连的本地内存区域。所以，理论上系统可以使用的内存有多大，元空间就有多大，所以不会出现永久代存在时的内存溢出问题。

在 jdk 1.7 及之前版本出现内存溢出的处理办法：

• 检查代码中是否出现死循环
• 是否创建了过多或过大的对象
• 是否出现死锁现象
• 提高 jvm 堆内存大小的配置

29 内存泄漏和内存溢出的区别

1. 内存溢出(out of memory)：指程序在申请内存时，没有足够的内存空间供其使用，出现 out of memory。
2. 内存泄露(memory leak)：指程序在申请内存后，无法释放已申请的内存空间，内存泄露堆积会导致内存被占光。
3. memory leak 最终会导致 out of memory。