JVM面试题总结

最新推荐文章于 2024-06-12 22:23:32 发布
最新推荐文章于 2024-06-12 22:23:32 发布
阅读量1w 收藏 101
点赞数 19
分类专栏： Java基础 文章标签： JVM JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38896998/article/details/86499993
版权

第一部分——JMM（Java内存模型）

1. 介绍下Java内存区域（运行时数据区）

在这里插入图片描述
JVM在执行Java程序的过程中会把它管理的内存分为若干个不同的区域，这些组成部分有些是线程私有的，有些则是线程共享的：

线程私有的：
  • 程序计数器
  • 虚拟机栈
  • 本地方法栈
线程共享的：
  • 方法区
  • 堆
  • 直接内存

1. 程序计数器

程序计数器是一块较小的内存空间，它的作用可以看做是当前线程所执行的字节码的行号指示器。
程序计数器是唯一一个不会出现OutOfMemoryError的内存区域，它的生命周期随着线程的创建而创建，随着线程的结束而死亡。

2. Java 虚拟机栈

与程序计数器一样，Java虚拟机栈也是线程私有的，它的生命周期与线程相同。虚拟机栈描述的是Java方法执行的内存模型：每个方法被执行的时候都会同时创建一个栈帧，用于存储局部变量表、操作栈、动态链接、方法出口等信息。每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。

在这里插入图片描述

Java 虚拟机栈会出现两种异常：StackOverFlowError 和 OutOfMemoryError。
  • StackOverFlowError： 若Java虚拟机栈的内存大小不允许动态扩展，那么当线程请求栈的深度超过当前Java虚拟机栈的最大深度的时候，就抛出StackOverFlowError异常。
  • OutOfMemoryError： 若 Java 虚拟机栈的内存大小允许动态扩展，且当线程请求栈时内存用完了，无法再动态扩展了，此时抛出OutOfMemoryError异常。

3. 本地方法栈

和虚拟机栈所发挥的作用非常相似，区别是： 虚拟机栈为虚拟机执行 Java 方法 （也就是字节码）服务，而本地方法栈则为虚拟机使用到的 Native 方法服务。 在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一。

4. 堆

堆是JVM内存占用最大，管理最复杂的一个区域。其唯一的用途就是存放对象实例：所有的对象实例及数组都在对上进行分配。1.7后，字符串常量池从永久代中剥离出来，存放在堆中。堆有自己进一步的内存分块划分，按照GC分代收集角度的划分请参见下图。

在这里插入图片描述

4.1 堆空间内存分配（默认情况下）
  • 老年代 ： 三分之二的堆空间
  • 年轻代 ： 三分之一的堆空间
    • eden区： 8/10 的年轻代空间
    • survivor0 : 1/10 的年轻代空间
    • survivor1 : 1/10 的年轻代空间

命令行上执行如下命令，查看所有默认的jvm参数

	java -XX:+PrintFlagsFinal -version
输出

输出有大几百行，这里只取其中的两个有关联的参数

[Global flags]
	uintx InitialSurvivorRatio                      = 8                                   {product}
	uintx NewRatio                                  = 2                                   {product}
    ... ...
java version "11" 2018-09-25
Java(TM) SE Runtime Environment 18.9 (build 11+28)
Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11+28, mixed mode)
参数解释
参数作用
-XX:InitialSurvivorRatio新生代Eden/Survivor空间的初始比例
-XX:NewratioOld区 和 Yong区 的内存比例
一道推算题

默认参数下，如果仅给出eden区40M，求堆空间总大小

根据比例可以推算出，两个survivor区各5M，年轻代50M。老年代是年轻代的两倍，即100M。那么堆总大小就是150M。

5. 方法区

方法区也是所有线程共享。主要用于存储类的信息、常量池、方法数据、方法代码等。方法区逻辑上属于堆的一部分，但是为了与堆进行区分，通常又叫“非堆”。

2. Java 对象的创建过程（五步，建议能默写出来并且要知道每一步虚拟机做了什么）

下图便是 Java 对象的创建过程，我建议最好是能默写出来，并且要掌握每一步在做什么。
在这里插入图片描述
①类加载检查： 虚拟机遇到一条 new 指令时，首先将去检查这个指令的参数是否能在常量池中定位到这个类的符号引用，并且检查这个符号引用代表的类是否已被加载过、解析和初始化过。如果没有，那必须先执行相应的类加载过程。

②分配内存： 在类加载检查通过后，接下来虚拟机将为新生对象分配内存。对象所需的内存大小在类加载完成后便可确定，为对象分配空间的任务等同于把一块确定大小的内存从 Java 堆中划分出来。分配方式有 “指针碰撞” 和 “空闲列表” 两种，选择那种分配方式由 Java 堆是否规整决定，而Java堆是否规整又由所采用的垃圾收集器是否带有压缩整理功能决定。

内存分配的两种方式：（补充内容，需要掌握）

选择以上两种方式中的哪一种，取决于 Java 堆内存是否规整。而 Java 堆内存是否规整，取决于 GC 收集器的算法是"标记-清除"，还是"标记-整理"（也称作"标记-压缩"），值得注意的是，复制算法内存也是规整的
在这里插入图片描述

内存分配并发问题（补充内容，需要掌握）

在创建对象的时候有一个很重要的问题，就是线程安全，因为在实际开发过程中，创建对象是很频繁的事情，作为虚拟机来说，必须要保证线程是安全的，通常来讲，虚拟机采用两种方式来保证线程安全：

  • CAS+失败重试： CAS 是乐观锁的一种实现方式。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。虚拟机采用 CAS 配上失败重试的方式保证更新操作的原子性。
  • TLAB： 为每一个线程预先在Eden区分配一块儿内存，JVM在给线程中的对象分配内存时，首先在TLAB分配，当对象大于TLAB中的剩余内存或TLAB的内存已用尽时，再采用上述的CAS进行内存分配

③初始化零值： 内存分配完成后，虚拟机需要将分配到的内存空间都初始化为零值（不包括对象头），这一步操作保证了对象的实例字段在 Java 代码中可以不赋初始值就直接使用，程序能访问到这些字段的数据类型所对应的零值。

④设置对象头： 初始化零值完成之后，虚拟机要对对象进行必要的设置，例如这个对象是那个类的实例、如何才能找到类的元数据信息、对象的哈希吗、对象的 GC 分代年龄等信息。 这些信息存放在对象头中。 另外，根据虚拟机当前运行状态的不同，如是否启用偏向锁等，对象头会有不同的设置方式。

⑤执行 init 方法： 在上面工作都完成之后，从虚拟机的视角来看，一个新的对象已经产生了，但从 Java 程序的视角来看，对象创建才刚开始，<init> 方法还没有执行，所有的字段都还为零。所以一般来说，执行 new 指令之后会接着执行 <init> 方法，把对象按照程序员的意愿进行初始化，这样一个真正可用的对象才算完全产生出来。

3. 对象的访问定位的两种方式（句柄和直接指针两种方式）

建立对象就是为了使用对象，我们的Java程序通过栈上的 reference 数据来操作堆上的具体对象。对象的访问方式有虚拟机实现而定，目前主流的访问方式有①使用句柄和②直接指针两种：

  1. 句柄： 如果使用句柄的话，那么Java堆中将会划分出一块内存来作为句柄池，reference 中存储的就是对象的句柄地址，而句柄中包含了对象实例数据与类型数据各自的具体地址信息；
    在这里插入图片描述
  2. 直接指针： 如果使用直接指针访问，那么 Java 堆对象的布局中就必须考虑如何放置访问类型数据的相关信息，而reference 中存储的直接就是对象的地址。
    在这里插入图片描述

这两种对象访问方式各有优势。使用句柄来访问的最大好处是 reference 中存储的是稳定的句柄地址，在对象被移动时只会改变句柄中的实例数据指针，而 reference 本身不需要修改。使用直接指针访问方式最大的好处就是速度快，它节省了一次指针定位的时间开销。

4. String类和常量池

1. String 对象的两种创建方式：

	 String str1 = "abcd";
     String str2 = new String("abcd");
     System.out.println(str1 == str2);//false

这两种不同的创建方法是有差别的，第一种方式是在常量池中拿对象，第二种方式是直接在堆内存空间创建一个新的对象。
在这里插入图片描述
记住： 只要使用new方法，便需要创建新的对象。

2. String 类型的常量池比较特殊。它的主要使用方法有两种：

  • 直接使用双引号声明出来的 String 对象会直接存储在常量池中。
  • 如果不是用双引号声明的 String 对象，可以使用 String 提供的 intern 方法。String.intern() 是一个 Native 方法，它的作用是：如果运行时常量池中已经包含一个等于此 String 对象内容的字符串，则返回常量池中该字符串的引用；如果没有，则在常量池中创建与此 String 内容相同的字符串，并返回常量池中创建的字符串的引用。
	String s1 = new String("计算机");
	String s2 = s1.intern();
	String s3 = "计算机";
	System.out.println(s2);//计算机
	System.out.println(s1 == s2);//false，因为一个是堆内存中的String对象一个是常量池中的String对象，
	System.out.println(s3 == s2);//true，因为两个都是常量池中的String对象

3. String 字符串拼接

	String str1 = "str";
	String str2 = "ing";
	
	String str3 = "str" + "ing";//常量池中的对象
	String str4 = str1 + str2; //在堆上创建的新的对象	  
	String str5 = "string";//常量池中的对象
	System.out.println(str3 == str4);//false
	System.out.println(str3 == str5);//true
	System.out.println(str4 == str5);//false

在这里插入图片描述
尽量避免多个字符串拼接，因为这样会重新创建对象。如果需要改变字符串的话，可以使用 StringBuilder 或者 StringBuffer。

String s1 = new String(“abc”);这句话创建了几个对象？
创建了两个对象。
验证：

	String s1 = new String("abc");// 堆内存的地值值
	String s2 = "abc";
	System.out.println(s1 == s2);// 输出false,因为一个是堆内存，一个是常量池的内存，故两者是不同的。
	System.out.println(s1.equals(s2));// 输出true

结果：

	false
	true

解释：
先有字符串"abc"放入常量池，然后 new 了一份字符串"abc"放入Java堆(字符串常量"abc"在编译期就已经确定放入常量池，而 Java 堆上的"abc"是在运行期初始化阶段才确定)，然后 Java 栈的 str1 指向Java堆上的"abc"。

5. 8种基本类型的包装类和常量池

  • Java 基本类型的包装类的大部分都实现了常量池技术，即Byte,Short,Integer,Long,Character,Boolean；这5种包装类默认创建了数值[-128，127]的相应类型的缓存数据，但是超出此范围仍然会去创建新的对象。
  • 两种浮点数类型的包装类 Float,Double 并没有实现常量池技术。
	Integer i1 = 33;
	Integer i2 = 33;
	System.out.println(i1 == i2);// 输出true
	Integer i11 = 333;
	Integer i22 = 333;
	System.out.println(i11 == i22);// 输出false
	Double i3 = 1.2;
	Double i4 = 1.2;
	System.out.println(i3 == i4);// 输出false
Integer 缓存源代码：
/**
*此方法将始终缓存-128到127（包括端点）范围内的值，并可以缓存此范围之外的其他值。
*/
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
应用场景：
  1. Integer i1=40；Java 在编译的时候会直接将代码封装成Integer i1=Integer.valueOf(40);，从而使用常量池中的对象。
  2. Integer i1 = new Integer(40);这种情况下会创建新的对象。
	Integer i1 = 40;
	Integer i2 = new Integer(40);
	System.out.println(i1==i2);//输出false
Integer比较更丰富的一个例子:
	Integer i1 = 40;
	Integer i2 = 40;
	Integer i3 = 0;
	Integer i4 = new Integer(40);
	Integer i5 = new Integer(40);
	Integer i6 = new Integer(0);
	
	System.out.println("i1=i2   " + (i1 == i2));
	System.out.println("i1=i2+i3   " + (i1 == i2 + i3));
	System.out.println("i1=i4   " + (i1 == i4));
	System.out.println("i4=i5   " + (i4 == i5));
	System.out.println("i4=i5+i6   " + (i4 == i5 + i6));   
	System.out.println("40=i5+i6   " + (40 == i5 + i6));
结果：
i1=i2   true
i1=i2+i3   true
i1=i4   false
i4=i5   false
i4=i5+i6   true
40=i5+i6   true

解释：

语句i4 == i5 + i6，因为+这个操作符不适用于Integer对象，首先i5和i6进行自动拆箱操作，进行数值相加，即i4 == 40。然后Integer对象无法与数值进行直接比较，所以i4自动拆箱转为int值40，最终这条语句转为40 == 40进行数值比较。

第二部分——JVM垃圾回收

1. 如何判断对象是否死亡（两种方法）

引用计数法
给对象中添加一个引用计数器，每当有一个地方引用它，计数器就加1；当引用失效，计数器就减1；任何时候计数器为0的对象就是不可能再被使用的。
这个方法实现简单，效率高，但是目前主流的虚拟机中并没有选择这个算法来管理内存，其最主要的原因是它很难解决对象之间相互循环引用的问题。


可达性分析算法
这个算法的基本思想就是通过一系列的称为 “GC Roots” 的对象作为起点，从这些节点开始向下搜索，节点所走过的路径称为引用链，当一个对象到 GC Roots 没有任何引用链相连的话，则证明此对象是不可用的。
不可达的对象并非“非死不可”
即使在可达性分析法中不可达的对象，也并非是“非死不可”的，这时候它们暂时处于“缓刑阶段”，要真正宣告一个对象死亡，至少要经历两次标记过程；可达性分析法中不可达的对象被第一次标记并且进行一次筛选，筛选的条件是此对象是否有必要执行 finalize 方法。当对象没有覆盖 finalize 方法，或 finalize 方法已经被虚拟机调用过时，虚拟机将这两种情况视为没有必要执行。
被判定为需要执行的对象将会被放在一个队列中进行第二次标记，除非这个对象与引用链上的任何一个对象建立关联，否则就会被真的回收。

在这里插入图片描述

2. 简单的介绍一下强引用、软引用、弱引用、虚引用（虚引用与软引用和弱引用的区别、使用软引用能带来的好处）。

1. 强引用
以前我们使用的大部分引用实际上都是强引用，这是使用最普遍的引用。如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。当内存空 间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。


2. 软引用（SoftReference）
如果一个对象只具有软引用，那就类似于可有可无的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。
软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，JAVA虚拟机就会把这个软引用加入到与之关联的引用队列中。


3. 弱引用（WeakReference）
如果一个对象只具有弱引用，那就类似于可有可无的生活用品。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。
弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
4. 虚引用（PhantomReference）
"虚引用"顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。
虚引用主要用来跟踪对象被垃圾回收的活动。
虚引用与软引用和弱引用的一个区别： 虚引用必须和引用队列（ReferenceQueue）联合使用。当垃 圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是 否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
特别注意，在程序设计中一般很少使用弱引用与虚引用，使用软引用的情况较多，这是因为软引用可以加速JVM对垃圾内存的回收速度，可以维护系统的运行安全，防止内存溢出（OutOfMemory）等问题的产生。

3. 如何判断一个常量是废弃常量？

假如在常量池中存在字符串 “abc”，如果当前没有任何String对象引用该字符串常量的话，就说明常量 “abc” 就是废弃常量，如果这时发生内存回收的话而且有必要的话，“abc” 就会被系统清理出常量池。

4. 如何判断一个类是无用的类？

判定一个常量是否是“废弃常量”比较简单，而要判定一个类是否是“无用的类”的条件则相对苛刻许多。类需要同时满足下面3个条件才能算是 “无用的类” ：

  1. 该类所有的实例都已经被回收，也就是 Java 堆中不存在该类的任何实例。
  2. 加载该类的 ClassLoader 已经被回收。
  3. 该类对应的 java.lang.Class 对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。

虚拟机可以对满足上述3个条件的无用类进行回收，这里说的仅仅是“可以”，而并不是和对象一样不使用了就会必然被回收。

5. 垃圾收集有哪些算法，各自的特点？

在这里插入图片描述

1. 标记-清除算法
标记-清除算法分为“标记”和“清除”阶段：首先标记出所有需要回收的对象，在标记完成后统一回收所有被标记的对象。它是最基础的收集算法，效率也很高，但是会带来两个明显的问题：

  1. 效率问题
  2. 空间问题（标记清除后会产生大量不连续的碎片）

在这里插入图片描述
2. 复制算法
为了解决效率问题，“复制”收集算法出现了。它可以将内存分为大小相同的两块，每次使用其中的一块。当这一块的内存使用完后，就将还存活的对象复制到另一块去，然后再把使用的空间一次清理掉。这样就使每次的内存回收都是对内存区间的一半进行回收。
在这里插入图片描述
3. 标记-整理算法
根据老年代的特点特出的一种标记算法，标记过程仍然与“标记-清除”算法一样，但后续步骤不是直接对可回收对象回收，而是让所有存活的对象向一端移动，然后直接清理掉端边界以外的内存。
在这里插入图片描述
4. 分代收集算法
当前虚拟机的垃圾收集都采用分代收集算法，这种算法没有什么新的思想，只是根据对象存活周期的不同将内存分为几块。一般将java堆分为新生代和老年代，这样我们就可以根据各个年代的特点选择合适的垃圾收集算法。
比如在新生代中，每次收集都会有大量对象死去，所以可以选择复制算法，只需要付出少量对象的复制成本就可以完成每次垃圾收集。而老年代的对象存活几率是比较高的，而且没有额外的空间对它进行分配担保，所以我们必须选择“标记-清除”或“标记-整理”算法进行垃圾收集

6. HotSpot为什么要分为新生代和老年代？

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

7. 常见的垃圾回收器有那些？

在这里插入图片描述
如果说收集算法是内存回收的方法论，那么垃圾收集器就是内存回收的具体实现。

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

1. Serial收集器
Serial（串行）收集器是最基本、历史最悠久的垃圾收集器了。大家看名字就知道这个收集器是一个单线程收集器了。它的 “单线程” 的意义不仅仅意味着它只会使用一条垃圾收集线程去完成垃圾收集工作，更重要的是它在进行垃圾收集工作的时候必须暂停其他所有的工作线程（ “Stop The World” ），直到它收集结束。
新生代采用复制算法，老年代采用标记-整理算法。
在这里插入图片描述
虚拟机的设计者们当然知道Stop The World带来的不良用户体验，所以在后续的垃圾收集器设计中停顿时间在不断缩短（仍然还有停顿，寻找最优秀的垃圾收集器的过程仍然在继续）。
但是Serial收集器有没有优于其他垃圾收集器的地方呢？当然有，它简单而高效（与其他收集器的单线程相比）。Serial收集器由于没有线程交互的开销，自然可以获得很高的单线程收集效率。Serial收集器对于运行在Client模式下的虚拟机来说是个不错的选择。
2. ParNew收集器
ParNew收集器其实就是Serial收集器的多线程版本，除了使用多线程进行垃圾收集外，其余行为（控制参数、收集算法、回收策略等等）和Serial收集器完全一样。
新生代采用复制算法，老年代采用标记-整理算法。
在这里插入图片描述
它是许多运行在Server模式下的虚拟机的首要选择，除了Serial收集器外，只有它能与CMS收集器（真正意义上的并发收集器，后面会介绍到）配合工作。
并行和并发概念补充：

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

3. Parallel Scavenge收集器
Parallel Scavenge 收集器类似于ParNew 收集器。 那么它有什么特别之处呢？

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

Parallel Scavenge收集器关注点是吞吐量（高效率的利用CPU）。CMS等垃圾收集器的关注点更多的是用户线程的停顿时间（提高用户体验）。所谓吞吐量就是CPU中用于运行用户代码的时间与CPU总消耗时间的比值。 Parallel Scavenge收集器提供了很多参数供用户找到最合适的停顿时间或最大吞吐量，如果对于收集器运作不太了解的话，手工优化存在的话可以选择把内存管理优化交给虚拟机去完成也是一个不错的选择。
新生代采用复制算法，老年代采用标记-整理算法。
在这里插入图片描述
4. Serial Old收集器
Serial收集器的老年代版本，它同样是一个单线程收集器。它主要有两大用途：一种用途是在JDK1.5以及以前的版本中与Parallel Scavenge收集器搭配使用，另一种用途是作为CMS收集器的后备方案。
5. Parallel Old收集器
Parallel Scavenge收集器的老年代版本。使用多线程和“标记-整理”算法。在注重吞吐量以及CPU资源的场合，都可以优先考虑 Parallel Scavenge收集器和Parallel Old收集器。
6. CMS收集器
CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器。它而非常符合在注重用户体验的应用上使用。
CMS（Concurrent Mark Sweep）收集器是HotSpot虚拟机第一款真正意义上的并发收集器，它第一次实现了让垃圾收集线程与用户线程（基本上）同时工作。
从名字中的Mark Sweep这两个词可以看出，CMS收集器是一种 “标记-清除”算法实现的，它的运作过程相比于前面几种垃圾收集器来说更加复杂一些。整个过程分为四个步骤：

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

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

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

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收集器在有限时间内可以尽可能高的收集效率（把内存化整为零）。

8. 介绍一下CMS,G1收集器。

CMS收集器
CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器。它而非常符合在注重用户体验的应用上使用。
CMS（Concurrent Mark Sweep）收集器是HotSpot虚拟机第一款真正意义上的并发收集器，它第一次实现了让垃圾收集线程与用户线程（基本上）同时工作。
从名字中的Mark Sweep这两个词可以看出，CMS收集器是一种 “标记-清除”算法实现的，它的运作过程相比于前面几种垃圾收集器来说更加复杂一些。整个过程分为四个步骤：

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

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

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

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收集器在有限时间内可以尽可能高的收集效率（把内存化整为零）。

9. Minor Gc和Full GC 有什么不同呢？

Minor GC：指发生新生代的的垃圾收集动作，Minor GC非常频繁，回收速度一般也比较快。
Major GC：指发生在老年代的GC，出现了Major GC经常会伴随至少一次的Minor GC（并非绝对），Major GC的速度一般会比Minor GC的慢10倍以上。
Full GC清理整个heap区，包括新生代和老年代。

第三部分——虚拟机性能监控和故障处理工具

JVM调优的常见命令行工具有哪些？

1. jps

JVM Process Status Tool,显示指定系统内所有的HotSpot虚拟机进程。

命令格式
jps [options] [hostid]

其中[option]、[hostid]参数也可以不写。

2. jstat

jstat(JVM statistics Monitoring)是用于监视虚拟机运行时状态信息的命令，它可以显示出虚拟机进程中的类装载、内存、垃圾收集、JIT编译等运行数据。

命令格式
jstat [option] LVMID [interval] [count]
3. jmap

jmap(JVM Memory Map)命令用于生成heap dump文件，如果不使用这个命令，还可以使用-XX:+HeapDumpOnOutOfMemoryError参数来让虚拟机出现OOM的时候·自动生成dump文件。
jmap不仅能生成dump文件，还可以查询finalize执行队列、Java堆和永久代的详细信息，如当前使用率、当前使用的是哪种收集器等。

命令格式
jmap [option] LVMID
4. jhat

jhat(JVM Heap Analysis Tool)命令是与jmap搭配使用，用来分析jmap生成的dump，jhat内置了一个微型的HTTP/HTML服务器，生成dump的分析结果后，可以在浏览器中查看。在此要注意，一般不会直接在服务器上进行分析，因为jhat是一个耗时并且耗费硬件资源的过程，一般把服务器生成的dump文件复制到本地或其他机器上进行分析。

命令格式

jhat [dumpfile]
5. jstack

jstack用于生成java虚拟机当前时刻的线程快照。线程快照是当前java虚拟机内每一条线程正在执行的方法堆栈的集合，生成线程快照的主要目的是定位线程出现长时间停顿的原因，如线程间死锁、死循环、请求外部资源导致的长时间等待等。 线程出现停顿的时候通过jstack来查看各个线程的调用堆栈，就可以知道没有响应的线程到底在后台做什么事情，或者等待什么资源。 如果java程序崩溃生成core文件，jstack工具可以用来获得core文件的java stack和native stack的信息，从而可以轻松地知道java程序是如何崩溃和在程序何处发生问题。另外，jstack工具还可以附属到正在运行的java程序中，看到当时运行的java程序的java stack和native stack的信息, 如果现在运行的java程序呈现hung的状态，jstack是非常有用的。

命令格式

jstack [option] LVMID

.

6. jinfo

jinfo(JVM Configuration info)这个命令作用是实时查看和调整虚拟机运行参数。
之前的jps -v口令只能查看到显示指定的参数，如果想要查看未被显示指定的参数的值就要使用jinfo口令

命令格式

jinfo [option] [args] LVMID

第四部分—— 类加载机制

1. 简单介绍一下Class类文件结构（常量池主要存放的是那两大常量？Class文件的继承关系是如何确定的？字段表、方法表、属性表主要包含那些信息？）

这篇文章很好的回答了这个问题

2. 简单说说类加载过程，里面执行了哪些操作？

3. 对类加载器有了解吗？

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

5. 双亲委派模型的工作过程以及使用它的好处。

这篇文章解答了2、3、4、5这几个问题

lollipop98
关注
  • 19
    点赞
  • 踩
  • 101
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
JAVA工程师面试专题-《JVM篇》
天空中不留下鸟的痕迹，但我已经飞过
02-20 1274
一个对象的 GC 年龄，是存储在对象头里面的（如图），一个 Java 对象在 JVM内存中的布局由三个部分组成，分别是对象头、实例数据、对齐填充。而对象头里面有 4 个 bit 位来存储 GC 年龄。而 4 个 bit 位能够存储的最大数值是 15，所以从这个角度来说，JVM 分代年龄之所以设置成 15 次是因为它最大能够存储的数值就是 15。虽然 JVM 提供了参数来设置分代年龄的大小，但是这个大小不能超过 15。
16道JVM面试题
2301_78021017的博客
06-12 2826
1.程序计数器：当前线程正在执行的字节码的行号指示器，线程私有，唯一一个没有规定任何内存溢出错误的情况的区域。 2.Java虚拟机栈：线程私有，描述Java方法执行的内存模型，每个方法运行时都会创建一个栈帧，存放局部变量表、操作数栈、动态链接、方法出口等信息，每个方法的运行到结束对应一个栈帧的入栈和出栈。会有StackOverFlowError异常（申请的栈深度大于虚拟机所允许深度）和OutOfMemoryError异常（线程无法申请到足够内存）。 3.本地方法栈：功能与Java虚拟机栈相同，不过是为Nat
JVM常见面试题及详解
热门推荐
ashfiqa的博客
01-26 2万+
虚拟机是一种抽象化的计算机，通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机有自己完善的硬体架构，如处理器、堆栈、寄存器等，还具有相应的指令系统。Java虚拟机屏蔽了与具体操作系统平台相关的信息，使得Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。简单来说JVM是用来解析和运行Java程序的。
【JVM】之常见面试题
最新发布
weixin_62848751的博客
06-12 1293
(User-Defined ClassLoader)，我们可以通过继承java.lang.ClassLoader类来创建自己的类加载器。
24个Jvm面试题总结及答案
2301_78145669的博客
07-01 2537
答：JVM中类的装载是由类加载器(ClassLoader)和它的子类来实现的，Java中的类加载器是一个重要的Java运行时系统组件，它负责在运行时查找和装入类文件中的类。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。答：GC是垃圾收集的意思，内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。
最全JVM面试题
weixin_45081813的博客
03-31 1万+
文章目录1.说一下 JVM 的主要组成部分及组成部分的作用？2.说一下 JVM 的作用？3.深拷贝和浅拷贝4.说一下堆栈的区别？5.队列和栈是什么？有什么区别？ 1.说一下 JVM 的主要组成部分及组成部分的作用？ 方法区和堆是所有线程共享的内存区域；而java栈、本地方法栈和程序员计数器是运行是线程私有的内存区域，运行时数据区域就是我们常说的JVM的内存。 类加载子系统：根据给定的全限定名类名(如：java.lang.Object)来装载class文件到运行时数据区中的方法区中。 Java堆
Java JVM 面试题总结
02-09
JVM 面试题总结 JVM 的主要作用是什么？ 请你描述一下 Java 的内存区域？ 请你描述一下 Java 中的类加载机制？ 在 JVM 中，对象是如何创建的？ 内存分配方式有哪些呢？ 请你说一下对象的内存布局？ 对象访问定位的...
JVM 面试题总结.md
08-11
JVM 面试题总结 - JVM 面试题总结 - JVM 的主要作用是什么？ - 请你描述一下 Java 的内存区域？ - 请你描述一下 Java 中的类加载机制？ - 加载 - 验证 - 准备 - 解析 - 初始化 - 使用 - 卸载 - 在 JVM ...
JVM核心知识点梳理以及JVM面试题总结
06-21
以下是对JVM核心知识点的详细梳理和面试题的总结： 1. **内存结构** - **堆（Heap）**：所有线程共享的内存区域，用于存储对象实例。堆分为新生代和老年代。 - **新生代** 包括Eden区、Survivor区（from和to）。...
100道 Jvm面试题总结及答案.docx
10-27
"Jvm 面试题总结及答案" Jvm 是 Java Virtual Machine 的缩写，即 Java 虚拟机。Jvm 是 Java 语言的 runtime 环境，它提供了 Java 语言的运行环境和相关的服务。Jvm 是 Java 语言的核心组件之一，它负责将 Java ...
Java虚拟机（JVM）面试题（总结最全面的面试题！！！）
12-21
Java虚拟机（JVM）是Java程序的核心组成部分，它使得Java具有“一次编写，到处运行”的跨...了解这些JVM面试题的关键知识点，有助于深入理解Java程序的运行机制和性能优化，是成为一名优秀的Java开发者不可或缺的知识。
2w 字长文爆肝 JVM 经典面试题！太顶了！，2024年最新java面试问到项目难点例子怎么写
2401_84102979的博客
04-12 326
虽然面试套路众多，但对于技术面试来说，主要还是考察一个人的技术能力和沟通能力。不同类型的面试官根据自身的理解问的问题也不尽相同，没有规律可循。上面提到的关于这些JAVA基础、三大框架、项目经验、并发编程、JVM及调优、网络、设计模式、spring+mybatis源码解读、Mysql调优、分布式监控、消息队列、分布式存储等等面试题笔记及资料。
BAT大厂Java面试必备：20道最新JVM面试题（含答案）
2401_84003115的博客
04-01 871
2021年的金三银四一眨眼就到了，对于很多人来说是跳槽的好机会，大厂面试远没有我们想的那么困难，摆好心态，做好准备，你也可以的。另外，面试中遇到不会的问题不妨尝试讲讲自己的思路，因为有些问题不是考察我们的编程能力，而是逻辑思维表达能力；最后平时要进行自我分析与评价，做好职业规划，不断摸索，提高自己的编程能力和抽象思维能力。BAT面试经验实战系列：Spring全家桶+Redis等其他相关的电子书：源码+调优24b （备注Java）**
十道JVM大厂面试题，看完直呼：太难了
03-14 1187
运行时常量池：是方法区的一部分。上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而hello这个字面量是放在堆中。2、请问jvm垃圾回收是否涉及栈内存？不需要。因为虚拟机栈中是由一个个栈帧组成的，在方法执行完毕后，对应的栈帧就会被弹出栈。所以无需通过垃圾回收机制去回收内存。3、虚拟机栈内存的分配越大越好吗？不是。因为物理内存是一定的，栈内存越大，可以支持更多的递归调用，但是可执行的线程数就会越少。
如何计算Eden区的大小
Decorator2015的博客
03-24 7256
如何计算Eden区的大小题目 已知虚拟机的一些参数设置如下： -Xms：1G； -Xmx：2G； -Xmn：500M； -XX:MaxPermSize：64M； -XX:+UseConcMarkSweepGC； -XX:SurvivorRatio=3； 求Eden区域的大小？ 分析 这是网易2016年在线笔试题中的一道选择题。
JVM面试题目与答案
Firstlucky77的博客
06-02 2592
JVM是Java运行基础,面试时一定会遇到JVM的有关问题,内容相对集中,但对只是深度要求较高。其中内存模型,类加载机制，GC是重点方面。性能调优部分更偏向应用，重点突出实践能力。编译器优化和执行模式部分偏向于理论基础，重点掌握知识点。需了解内存模型各部分作用，保存哪些数据。类加载双亲委派加载机制，常用加载器分别加载哪种类型的类。GC分代回收的思想和依据以及不同垃圾回收算法的回收思路和适合场景。性能调优常有JVM优化参数作用，参数调优的依据，常用的JVM分析工具能分析哪些问题以及使用方法。执行模式解释/编译
JVM面试题（含答案和图和解释）
m0_45364328的博客
07-14 1510
一个类什么时候被加载，《java虚拟机规范》中并没有强制约束，而是交给虚拟机自由实现，HotSpot虚拟机是按需加载，在需要用到该类的时候加载这个类 首先去检查这个指令的参数能否在Metaspace的常量池中定位到一个类的符号引用，并且检查这个类的符号引用代表的类是否已经被加载、解析、初始化。（即判断类元信息是否存在）如果没有，那么在双亲委派模式下，使用当前了类加载器以ClassLoader+包名+类名为key进程查找对应的.class文件。如果没有找到文件，则抛出ClassNotFoundExceptio
JVM：堆(Heap)和非堆(Non-heap)内存
blueheartstone的博客
01-29 2568
jvm
110道 Jvm面试题总结及答案 （持续更新）
架构师专栏
12-01 1万+
最新Jvm面试题总结及答案【附答案解析】Jvm面试题及答案2021，Jvm面试题最新面试题，Jvm面试题新答案已经全部更新完了，有些答案是自己总结的，也有些答案是在网上搜集整理的。这些答案难免会存在一些错误，仅供大家参考。如果发现错误还望大家多多包涵，不吝赐教，谢谢~ 如果不背 Jvm面试题的答案，肯定面试会挂！ 这套Jvm面试题大全，希望对大家有帮助哈~ 博主已将以下这些面试题整理成了一个面试手册，是PDF版的 1、谈谈动态年龄判断 1、这里涉及到 -XX:TargetSurvivorRati.
Jvm面试题总结：动态年龄判断、类初始化和GC机制
Jvm面试题总结及答案 Jvm面试题总结及答案是Java虚拟机（Jvm）领域的一份重要的面试题总结，涵盖了Jvm的各个方面，包括Jvm的内存管理、垃圾回收、类加载、对象生命周期等。下面是对Jvm面试题总结及答案中的一些...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值