JVM常见面试题目

Java内存区域

说一下 JVM 的主要组成部分及其作用？

JVM包含两个子系统和两个组件，两个子系统为Class loader(类加载)，Execution engine()执行引擎；两个组件分别为Runtime data area(运行时数据区)，Native Interface（本地接口）

• Class loader(类加载)：根据给定的全限定名类名（如：java.lang.Object）来装载class文件到Runtime data area中的method area。
• Execution engine(执行引擎):执行classes中的指令。
• Native Interface（本地接口）:与native libraries交互，是其他编程语言交互的接口。
• Runtime data area(运行时数据区域)：这就是我们常说的JVM内存
  作用：首先通过编译器把Java代码转换成字节码，类加载器（Class loader）再把字节码加载到内存中，将其放在运行时数据区（Runtime data area）的方法区内，而字节码文件只是JVM的一套指令集规范，并不能直接交给底层操作系统区执行，因此需要特定的命令解析执行引擎（Execution Engine）,将字节码翻译成底层系统指令，再交由CPU去执行，而这个过程需要调用其他语言的本地库接口（Native Interface）来实现整个程序的功能。
  下面是Java程序运行机制详细说明
  Java程序运行机制步骤

1. 首先利用IDE集成开发工具编写Java源代码，源文件的后缀为.java；
2. 再利用编译器（javac命令）将源代码编译成字节码文件，字节码文件的后缀名为.class；
3. 运行字节码的工作是由解释器（java命令）来完成的。
   
   从上图可以看出，java文件通过编译器变成了.class文件，接下来类加载器又将这些.class文件加载到JVM中。
   其实可以一句话来解释：类加载指的是将类.class文件中的而二进制数据读入到内存中，将其放在运行时数据区的方法内，然后在堆区创建一个java.lang.Class对象，用来封装类在方法区内的数据结构。

说一下 JVM 运行时数据区

java虚拟机在执行Java程序的过程中会把它所管理的内存区域划分为若干个不同的数据区域。这些数据区域都有各自的用途，以及创建和销毁的时间，有些区域随着虚拟机进程的启动而存在，有些区域则是依赖线程的启动和结束而建立和销毁的。Java虚拟机所管理的内存被划分为以下几个区域：

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

• 程序计数器（Program Counter Register）:当前线程所执行的字节码的行号指示器，字节码解析器的工作是通过改变这个计数器的值，来选取下一条需要执行的字节码指令，分支，循环，跳转，异常处理，线程恢复等基础功能，都需要依赖这个计数器来完成；
• Java虚拟机栈（Java Viryual Machine Stacks）:用于存储局部变量表，操作数栈，动态链接，方法出口等信息；
• 本地方法栈(Native Method Stack)：与虚拟机栈的作用是一样的，只不过虚拟机栈是服务Java方法的，而本地方法栈是为虚拟机调用Native方法服务的；
• Java堆（Java Heap）：java虚拟机中内存最大的一块，是被所有线程共享的，几乎所有的对象实例都在这里分配内存；
• 方法区（Method Area）：用于存储已被虚拟机加载的类信息，常量，静态变量，即时编译后的代码等数据。

深拷贝和浅拷贝

• 浅拷贝（shallowCopy）只是增加了一个指针指向已存在的内存地址
• 深拷贝（deepCopy）是增加了一个指针并申请了一个新的内存，使这个增加的指针指向这个新的内存，使用深拷贝的情况下，释放内存的时候不会因为出现浅拷贝时释放同一个内存的错误
• 浅复制：仅仅是指向被复制的内存地址，如果原地址发生改变，那么浅复制出来的对象也会相应的改变。
• 深复制：在计算机中开辟一块新的内存地址用于存放复制的对象。

说一下堆栈的区别？

1. 物理地址

• 堆的物理地址分配对对象是不连续的，因此性能较慢。在GC的时候也要考虑不连续的分配，所以有各种算法，比如，标记清除，标记整理，复制，分代等算法
• 栈使用的是数据结构中的栈，先进后出的原则，物理地址分配是连续的，所以性能较快

2. 内存分别

• 堆因为是不连续的，所以分配的内存是在运行期确认的，因此大小不固定，一般堆大小远远大于栈
• 栈是连续的，所以分配的内存大小要在编译器就确认，大小是固定的。

3. 存放的内容

• 堆存放的是对象的实例和数组，因此该区更关注的是数据的存储
• 栈存放：局部变量，操作数栈，返回结果。该区更关注的是程序方法的执行。
  PS:
• 静态变量放在方法区
• 静态的对象还是放在堆
  程序的可见度
  堆对于整个应用程序都是共享的，可见的
  栈只对于线程是可见的。所以也是线程私有的，它的生命周期和线程相同。

队列和栈是什么？有什么区别？

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

• 操作的名称不同，队列的插入和删除被称为入队和出队，栈的插入和删除被称为进栈和出栈
• 可操作的方法不同。队列是在队尾入队，队头出队，即两边都可以操作。而栈的进栈和出栈都是在栈顶进行的，无法堆栈底直接进行操作
• 操作的方法不同。队列是先进先出（FIFO），即队列的修改是依先进先出的原则进行的。新来的成员总是加入队尾（不能从中间插入），每次离开的成员总是队列头出队（不允许中途离队）。而栈为后进先出（LIFO），即每次删除（出栈）的总是当前栈中最新的元素，即最后插入（进栈）的元素，而最先插入的被放在栈的底部，要到最后才能删除。

HotSpot虚拟机对象探秘

对象的创建

java中提供的几种对象创建方式：

Header	解释
使用new关键	调用了构造函数
使用Class的newInstance方法	调用了构造函数
使用Constructor类的newInstance方法	调用了构造函数
使用了clone方法	没有调用构造函数
使用反序列化	没有调用构造函数

• 对象创建的流程
  
  虚拟机遇到一条new指令时，会先检查常量池是否已经加载相应的类，如果没有，必须先执行相应的类加载。类加载通过后，接下来分配内存。若Java堆中内存是绝对规整的，使用“指针碰撞”方式分配内存；如果内存不规整的，就从空闲列表中分配，叫做“空闲列表”方式。划分内存时还需要考虑一个问题-并发，也有两种方式：CAS同步处理，或者本地线程分配缓存（Thread Local Allocation Buffer,TLAB）。然后内存空间初始化操作，接着是做一些必要的对象设置（元信息，哈希码。。），最后执行方法。

为对象分配内存

类加载完成后，接着会在Java堆中划分一块内存分配给对象。内存分配根据Java堆是否规整，有两种方式：

• 指针碰撞：如果Java堆的内存是规整，即所有用过的内存放在一边，而空闲的放在另一边，分配内存时将位于中间的指针指示器向空闲的内存移动一段与对象大小相等的距离，这样便完成了内存工作。
• 空闲列表：如果Java堆的内存不是规整的，则需要由虚拟机维护一个列表来记录哪些内存是可用的，这样在分配的时候可以从列表中查询到足够大的内存分配给对象，并在分配后更新列表记录。
  选择哪种分配方式是由Java堆是否规整来决定的，而Java堆是否规整又是由所采用的垃圾收集器是否带有压缩整理功能决定的
  

处理并发安全问题

对象的创建在虚拟机中是一个非常频繁的行为，哪怕只是修改了一个指针所指向的位置，在并发情况下也是不安全，可能出现正在给对象A分配内存，指针还没来得及修改，对象B又同时使用了原来的指针来分配内存的情况，解决这两个问题的两种方案：

• 对分配内存空间的动作进行同步处理（采用CAS+失败重试来保障更新操作的原子性）
• 把内存分配的动作按照线程划分在不同的空间中进行，即每个线程在Java堆中预先分配一小块内存，称为本地线程分配缓冲（Thread Local Allocation Buffer,TLAB）。哪个线程需要分配内存，就在哪个线程的TLAB上分配。只有TLAB用完并分配新的TLAB时，才需要同步锁。通过-XX:+/UserTLAB参数来设定虚拟机是否使用TILAB。
  

对象的访问定位

Java程序需要通过JVM栈上的引用访问堆中的具体对象。对象的访问取决于JVM虚拟机的实现。目前主流的访问方式有句柄和直接指针两种方法。

指针：指向对象，代表一个对象在内存中的起始地址
句柄：可以理解为指向指针的指针，维护着对象的指针。句柄不直接指向对象，而是指向对象的指针（句柄不发生变化，指向固定内存地址），再由对象的指针地址指向对象的真实内存地址。

• 句柄访问
  Java堆中划分出一块内存来作为句柄池，引用存储对象的句柄地址，而句柄中包含了对象实例数据与对象类型数据各自的具体地址信息，具体构造如下：
  
  优势：引用中存储的是稳定的句柄地址，在对象被移动（垃圾收集时移动对象是非常常见的）时只会改变句柄中的实例数据指针，而引用本身不需要修改
• 直接指针
  如果使用直接指针访问，引用中存储的直接就是对象地址，那么Java堆对象内部的布局中就必须考虑如何放置访问类型数据的相关信息。
  
  优势：速度更快，节省了一次指针定位的时间开销。由于对象的访问在Java中非常频繁，因此这类开销积少成多也是非常可观的执行成本。HotSpot中采用的就是这种方式。

内存溢出异常

Java会存在内存泄漏吗？请简单描述

内存泄漏是指不再被使用的对象或者变量一直被占据在内存中，理论上说，Java有GC垃圾回收机制的，也就是说不再被使用的对象，会被GC自动回收掉，自动从内存中清除。
但是，即使这样，Java也还是存在着内存泄漏的情况，java导致内存泄漏的原因很明确：长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄漏，尽管短生命周期的对象已经不再需要了，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是Java中内存泄漏的发生场景。

垃圾收集器

简单描述一下垃圾回收机制

在java中，程序员是不需要显示的去释放一个对象的内存的，而是由虚拟机自行执行，在JVM中，有一个垃圾回收线程，它是低优先级的，在正常情况下是不会执行的，只有在虚拟机空闲或者当前堆内存不足时，才会触发执行，扫描那些没有被任何引用的对象，并将它们添加到要回收的集合中，进行回收。

GC是什么？为什么要GC？

GC是垃圾收集的意思（Gabage Collection），内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动检查对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。

垃圾回收的优点和原理，并考虑2种回收机制

java语言最显著的特点就是引入了垃圾回收机制，它使java程序员在编写程序时不再考虑内存管理的问题。
由于有这个垃圾回收机制，java中的对象不再有“作用域”的概念，只有引用的对象才有作用域。
垃圾回收机制有效防止了内存泄漏，可以有效的使用可使用内存。
垃圾回收器通常作为一个单独的低级别的线程运行，在不可预知的情况下对内存堆中已经死亡的或很长时间没有用过的对象进行清除和回收。
程序员不能实时的对某个对象或所有对象调用垃圾回收器进行垃圾回收。
垃圾回收有分代，标记清除，标记整理，复制算法

垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？

对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址，大小以及使用情况。
通常，GC采用有向图的方式记录和管理堆（Heap）中的所有对象。通过这种方式确定哪些对象是可达的，哪些对象是不可达的。当GC确定一些对象不可达时，GC就有责任回收这些内存空间。
可以，程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。

Java中都有哪些引用类型？

• 强引用：发生gc都不会被回收
• 软引用：有用但不是必须的对象，在发生内存溢出之前会被回收
• 弱引用：有用但不是必须的对象，在下次GC时会被回收
• 虚引用（幽灵引用/幻影引用）：无法通过虚引用获得对象，用PhantomReference实现虚引用，虚引用的用途是在gc时返回一个通知。

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

垃圾收集器在做垃圾回收的时候，首先需要判定的就是哪些内存是需要被回收的，哪些对象是存活的，是不可以被回收的；哪些对象已经死了，需要被回收。
一般有两种方法来判断：

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

在Java中，对象什么时候可以被垃圾回收

当对象对当前使用这个对象的应用程序变得不可触及的时候，这个对象就可以被回收了。
垃圾回收不会发生在永久代，如果永久代满了或者超过了临界值，会触发完全垃圾回收（Full GC）。如果你仔细查看垃圾收集器的输出信息，就会发现永久代也是被回收的。这就是为什么正确的永久代大小对避免Full GC是非常重要的原因。

JVM中的永久代中会发生垃圾回收吗

垃圾回收不会发生在永久代，如果永久代满了或者是超过了临界值，会触发完全垃圾回收(Full GC)。如果你仔细查看垃圾收集器的输出信息，就会发现永久代也是被回收的。这就是为什么正确的永久代大小对避免Full GC是非常重要的原因。请参考下Java8：从永久代到元数据区。

说一下 JVM 有哪些垃圾回收算法？

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

标记-清除算法

标记无用对象，然后进行清除回收
标记-清除算法（Mark-Sweep）是一种常见的基础垃圾收集算法，它将垃圾收集分为两个极端：

• 标记阶段：标记出可以回收的对象
• 清除阶段：回收被标记的对象所占用的空间。
  标记-清除算法之所以是基础的，是因为下面的垃圾收集算法都是在此算法的基础上进行改进的
  优点：实现简单，不需要对象进行移动。
  缺点：标记，清除过程效率低，产生大量不连续的内存碎片，提高了垃圾回收的频率
  标记-清除算法的执行过程如下：
  

复制算法

为了解决标记-清除算法的效率不高的问题，产生了复制算法，它把内存空间划分为两个相等的区域，每次只是用其中一个区域，垃圾收集时，遍历当前使用的区域，把存活对象复制到另外一个区域中，最后将当前使用的区域的可回收的对象进行回收。
优点：按顺序分配内存即可，实现简单，运行高效，不用考虑内存碎片
缺点：可用的内存大小缩小为原来的一半，对象存活率高时会频繁进行复制
复制算法的执行过程如下：

标记-整理算法

在新生代中可以使用复制算法，但是在老年代中就不能选择复制算法，因为老年代的对象存活率会较高，这样会有比较多的复制操作，导致效率变低。标记-清除算法可以应用在老年代中，但是它效率不高，在内存回收时容易产生大量内存碎片。因此就出现了一种标记-整理算法（Mark-Compact）算法，与标记-整理算法不同的是，在标记可回收的对象后将所有存活的对象压缩到内存的一端，是他们紧凑的排列在一起，然后对端边界意外的内存进行回收，回收后，已用的和未用的内存都各自一边。
优点：解决了标记-清理算法存在的内存碎片问题
缺点：仍需要及逆行局部对象移动，一定程度上降低了效率
标记-整理算法的执行过程如下：

分代收集算法

当前商业虚拟机都采用分代收集的垃圾收集算法，分代收集算法，顾名思义就是根据对象的存活周期将内存划分为几块，一般包括年轻代，老年代和永久代（JAVA8中已经改为元空间）

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

如果说垃圾收集算法是内存回收的方法论，那么垃圾收集器就是内存回收的具体实现。下面是7种作用于不同分代的收集器，其中用于回收新生代的收集器包括Serial,PraNew,Parallel Scavenge,回收老年代的收集器包括Serial Old,Parallel Old,CMS，还有用于回收整个Java堆的G1收集器。不同收集器之间的连线表示它们可以搭配使用。

• Serial收集器（复制算法）：新生代单线程收集器，标记和清理都是单线程，优点是简单高效；
• ParNew收集器（复制算法）：新生代并行收集器，实际上是Serial收集器的多线程版本，在多核CPU环境下有着比Serial更好的表现；
• Parallel Scavenge收集器（复制算法）：新生代并行收集器，追求高吞吐量，高效利用CPU。吞吐量=用户线程时间/（用户线程时间+GC线程时间），高吞吐量可以高效的利用CPU时间，尽快完成程序的运算任务，适合后台应用等对交互相应要求不高的场景；
• Serial Old收集器（标记-整理算法）：老年代单线程收集器，Serial收集器的老年代版本；
• Parallel Old（标记-整理算法）：老年代并行收集器，吞吐量优先，Parallel Scavenge收集器的老年代版本；
• CMS（Concurrent Mark Sweep）收集器（标记-清除算法）：老年代并行收集器，以获取最短回收停顿时间为目标的收集器，具有高并发，低停顿的特点，追求最短GC回收停顿时间。
• G1（Garbage First）收集器（标记-整理算法）:Java堆并行收集器，G1收集器是JDK1.7提供的一个新收集器，G1收集器基于标记-整理算法实现，也就是说不会产生内存碎片，此外，G1收集器不同于之前的收集器的一个重要特点是：G1回收的范围是整个Java堆（包括新生代，老年代），而前六种收集器的回收范围仅限于新生代或老年代。

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

CMS是英文Concurrent Mark-Sweep的简称，是以牺牲吞吐量为代价来获得最短回收停顿时间的垃圾回收器。对于要求服务器响应速度的应用上，这种垃圾回收器非常适合，在启动JVM的参数加上“-XX:+UseConcMarkSweepGC”来指定使用CMS垃圾回收器
CMS使用的是标记清除算法实现的，所以在gc的时候会产生大量的内存碎片，当剩余内存不能满足程序运行要求时，系统将会出现Concurrent Mode Failure，临时CMS会采用Serial Old回收器进行垃圾清除，此时的性能将会被降低。

新生代垃圾回收器和老年代垃圾回收器都有哪些？有什么区别？

• 新生代垃圾回收器：Serial,ParNew,Parallel Scavenge
• 老年代垃圾回收器：Serial Old,Parallel Old,CMS
• 整个堆垃圾回收器：CMS
  新生代垃圾回收器一般采用的都是复制算法，复制算法的优点是效率高，缺点是内存利用率低；老年代垃圾回收器一般采用的是标记-整理算法进行垃圾回收。

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

分代回收器有两个分区：老年代和新生代，新生代默认的空间占比总空间的1/3，老年代的默认占比是2/3。
新生代使用的是复制算法，新生代里面有3个分区：Eden,To Surivor,From Surivor，它们的默认占比是8：1：1，它的执行流程如下：

• 把Eden+From Surivor存活的对象放入To Surivor区
• 清空Eden和From Surivor分区
• From Surivor和To Surivor分区交换，From Surivor变To Surivor，To Surivor变From Surivor。
  每次在From Surivor到To Surivor移动时都存活的对象，年龄就+1，当年龄到达15（默认配置是15）时，升级为老年代。大对象也会直接进入老年代。
  老年代当空间占用到达某个值之后就会触发全局垃圾回收，一般使用标记整理的执行算法。以上这些循环往复就构成了整个分代垃圾回收的整体执行流程。

内存分配策略

简述java内存分配与回收策略以及Minor GC和Major GC

所谓自动内存管理，最终要解决的也就是内存分配和内存回收两个问题。内存回收上面已经讲过了，下面来说一下内存分配。
对象的内存分配通常是在java堆上分配的（随着虚拟机优化技术的诞生，某些场景下也会在栈上分配），对象主要分配在新生代Eden区，如果启动了本地线程缓冲，将按照线程优先在TLAB上分配。少数情况下也会直接在老年代上分配。总的来说分配规则不是固定的，其细节取决于哪一种垃圾收集器组合以及虚拟机相关参数等，但是虚拟机对于内存的分配还是会遵循以下几种规则：

对象优先在 Eden 区分配

多数情况下，对象都在新生代Eden区分配。当Eden区分配没有足够的空间进行分配时，虚拟机会发起一次Minor GC,如果本次GC后还是没有足够的空间，则将启用分配担保机制在老年代中分配内存。
这里提高Minor GC,如果仔细观察过GC日常，会在日志中发现Minor GC /Full GC

• Minor GC是指发生在新生代的GC，因为Java对象大多都是朝生夕死，所以Minor GC非常频繁，一般回收速度比较快
• Major GC/Full GC是指发生在老年代的GC，出现了Major GC通常会伴随至少一次Minor GC。Major GC的速度通常会比Minor GC慢10倍以上。

大对象直接进入老年代

所谓大对象是指需要大量连续内存空间的对象，频繁出现大对象是致命的，会导致在内存还有不少空间的情况下提前触发GC以获取足够的连续空间来安置新对象。
前面说过新生代使用的是复制算法来处理垃圾回收，如果大对象直接在新生代分配就会导致Eden区和两个Surivor区之间发生大量的内存复制，因此对于大对象都会直接在老年代进行分配。

长期存活对象将进入老年代

虚拟机采用分代收集的思想来管理内存，那么内存回收时就必须判断哪些对象应该放在新生代，哪些对象应该放在老年代，因此虚拟机给每个对象定义了一个对象年龄的计数器，如果对象在Eden区出生，并且能够被Surivor容纳，将被移动到Surivor空间中，这时设置对象年龄为1，对象在Surivor区中每熬过一次Minor GC年龄就加1，当年龄达到一定程度（默认15）就会被晋升到老年代。

虚拟机类加载机制

简述java类加载机制？

虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验，解析，初始化，最终形成可以被虚拟机直接使用的java类型。

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

Java中的所有类，都需要由类加载器装载到JVM中才能运行。类加载器本身也是一个类，而它的工作就是把class文件从硬盘读取到内存中。在写程序的时候，我们几乎不需要关心类的加载，因为这些都是隐式加载的，除非我们有特殊用法，像反射，就需要显示的加载所需要的类
类装载方式，有两种：

1. 隐式装载：程序在运行过程中当碰到new等方式生产对象时，隐式调用类加载器加载对应的类到jvm中
2. 显示装载：通过class.forname等方法，显示加载需要的类。

Java类的加载是动态的，它并不会一次性将所有类全部加载后再运行，而是保证程序运行的基础类（像是基类）完全加载到jvm中，至于其他类，则在需要的时候才加载，这当然就是为了节省内存开销。

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

实现通过类的全限定名获取该类的二进制字节流的代码块叫做类加载器
主要有以下四种类加载器：

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类的方式实现。

说一下类装载的执行过程？

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

• 加载：根据查找路径找到相应的class文件然后导入；
• 验证：检查加载的class文件的正确性；
• 准备：给类中的静态变量分配内存空间；
• 解析：虚拟机将常量池中的符号引用替换成直接引用的过程。符号引用就理解为一个标识，而在直接引用直接指向内存中的地址；
• 初始化：对静态变量和静态代码块执行初始化工作。

什么是双亲委派模型？

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

类加载器分类：

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

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

JVM调优

说一下 JVM 调优的工具？

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

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

常用的 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详细信息；