Java中垃圾回收常见面试题

最新推荐文章于 2024-08-03 15:40:39 发布

Barry_HHK

最新推荐文章于 2024-08-03 15:40:39 发布

阅读量1.7k

点赞数 24

文章标签： java jvm 算法

本文链接：https://blog.csdn.net/qq_47474185/article/details/140363028

版权

在堆内存中，从垃圾回收的范围上说，一般分为两种：

针对新生代的垃圾回收动作：minorGC（YoungGC或YGC）

针对老年代的垃圾回收动作：majorGC(fullGC或FGC)

由于majorGC动作发生的时候通常伴随着minorGC，所以major通常也叫fullGC或FGC

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

1.引用计数法

这种方法为每个对象维护一个引用计数器。当有一个地方引用该对象时，计数器加一；当引用失效时，计数器减一。任何时刻引用计数为零的对象就是可以被回收的。

优点：

实现简单，判断对象是否可以回收的效率高。

缺点：

无法检测到循环引用的情况。即两个对象相互引用，虽然它们都没有被其它地方引用，但它们的引用计数都不为零，导致无法被回收。

2.可达性分析法

这种方法通过一系列称为“GC Roots”的对象作为起始点，沿着这些节点向下搜索。搜索所走过的路径称为引用链（Reference Chain）。当一个对象到 GC Roots 没有任何引用链相连（即不可达）时，则说明该对象是不可用的，可以被回收。

GC Roots 常见的节点包括：

虚拟机栈中引用的对象。
方法区中类静态属性引用的对象。
方法区中常量引用的对象。
本地方法栈中 JNI（即一般说的 Native 方法）引用的对象。

优点：

能够准确地判断对象的可达性，解决了引用计数法的循环引用问题。

缺点：

相对于引用计数法，分析过程较为复杂，开销较大。

public class ReferenceCountingGC {
    public Object instance = null;
    private static final int _1MB = 1024 * 1024;

    private byte[] bigSize = new byte[2 * _1MB];

    public static void main(String[] args) {
        ReferenceCountingGC objA = new ReferenceCountingGC();
        ReferenceCountingGC objB = new ReferenceCountingGC();
        objA.instance = objB;
        objB.instance = objA;

        objA = null;
        objB = null;

        // 假设在此行发生 GC，objA 和 objB 是否能被回收？
        System.gc();
    }
}
//在上述代码中，如果使用引用计数法，objA 和 objB 将无法被回收，因为它们相互引用，引用计数不为
//零；但是，如果使用可达性分析法，由于它们都不可达（没有任何引用链指向它们），因此它们可以被回收。

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

强引用 (Strong Reference)

定义：强引用是 Java 中最常见的引用类型，类似于 Object obj = new Object(); 这样的引用。
特性：只要一个对象有强引用存在，垃圾回收器就不会回收它。这意味着即使内存不足，JVM 也不会回收强引用的对象，而会抛出 OutOfMemoryError。

Object obj = new Object();

软引用 (Soft Reference)

定义：软引用可以通过 java.lang.ref.SoftReference 类来实现。
特性：软引用的对象只有在内存不足时才会被垃圾回收器回收。这使得软引用非常适合用于实现内存敏感的缓存。
使用场景：适用于缓存，实现类似于 "最近最少使用" (Least Recently Used, LRU) 的缓存策略。

SoftReference<Object> softRef = new SoftReference<>(new Object());
Object obj = softRef.get();
if (obj == null) {
    // 对象已被回收，需要重新加载
}

弱引用 (Weak Reference)

定义：弱引用可以通过 java.lang.ref.WeakReference 类来实现。
特性：弱引用的对象只要有垃圾回收运行就会被回收，无论内存是否充足。弱引用适合用来表示非必需的对象，如映射数据。

使用场景：用于实现 WeakHashMap，即在不再使用键时回收其对应的值。

WeakReference<Object> weakRef = new WeakReference<>(new Object());
Object obj = weakRef.get();
if (obj == null) {
    // 对象已被回收，需要重新加载
}

虚引用 (Phantom Reference)

定义：虚引用可以通过 java.lang.ref.PhantomReference 类来实现。
特性：虚引用并不会直接影响对象的生命周期。它的作用是在对象被垃圾回收之后得到一个通知，用来做清理工作。与软引用和弱引用不同，虚引用在任何时候都可能被垃圾回收。
使用场景：用于管理堆外内存、检测对象被垃圾回收后的清理操作。

PhantomReference<Object> phantomRef = new PhantomReference<>(new Object(), new ReferenceQueue<>());

区别与使用场景

强引用：最常见的引用类型，不会被垃圾回收，适用于必须持有的对象。
软引用：适用于实现缓存，只有在内存不足时才会被回收，有助于提高程序的内存利用率。
弱引用：适用于实现映射数据，如 WeakHashMap，能让垃圾回收器及时回收不再使用的对象，避免内存泄漏。
虚引用：适用于监控对象被回收的情况，用于资源释放、管理堆外内存等场景。

使用软引用的好处

缓存机制：软引用非常适合用于实现缓存，能够在内存紧张时释放缓存对象，从而提高内存利用率。
内存敏感应用：在内存敏感的应用中，软引用能确保在系统内存不足时优先回收不重要的缓存对象，减少内存占用。
性能优化：软引用的使用可以减少内存泄漏，提高应用程序的稳定性和性能。

如何判断一个常量是废弃常量

jdk1.7及以前：常量池在方法区中

判断一个常量是否是废弃常量，主要涉及到在运行时对方法区中的常量池进行管理。废弃常量指的是在常量池中不再被任何地方引用的常量。在 JVM 中，对常量的管理主要依靠垃圾回收机制来判断和回收不再使用的常量。具体来说，有以下几个关键点：

常量池的类型

常量池主要包括：

字符串常量池：存储字符串常量。
类常量池：存储类、方法、字段的符号引用等。

判断常量是否废弃的过程

引用计数法：
- 对常量池中的每个常量维护一个引用计数器。
- 每次常量被引用时，引用计数加一；每次引用失效时，引用计数减一。
- 引用计数为零的常量即为废弃常量。
可达性分析法：
- 从 GC Roots 开始，遍历所有可达对象。
- 标记常量池中所有在引用链上的常量。
- 没有被标记的常量即为废弃常量。

具体实现

1. 字符串常量池

字符串常量池是 JVM 中的一部分，专门存放字符串常量。JVM 会在加载类时，将所有字符串常量放入字符串常量池中，并对其进行管理。

字符串常量的生命周期：字符串常量通常在类加载时创建，并在类卸载时被回收。
判断废弃字符串常量
- 当一个类卸载时，其字符串常量也会被回收。
- JVM 在进行垃圾回收时，会检测字符串常量池中是否有不再被引用的字符串常量，并进行回收。

2.类常量池

类常量池存储了类文件中的常量，包括方法和字段的符号引用等。

类常量池的管理：
- JVM 会在类加载时，将类文件中的常量加载到类常量池中。
- 在类卸载时，类常量池中的常量也会被回收。
判断废弃类常量：
- 类常量通常在类卸载时被回收。
- JVM 在进行垃圾回收时，会检测类常量池中是否有不再被引用的常量，并进行回收。

JDK 1.8 及以后：常量池在堆中

运行时常量池 (Runtime Constant Pool)：
- 存储在堆中，包含类文件常量池的各种字面量和符号引用。
- 类加载时将类文件的常量池加载到运行时常量池中。
字符串常量池 (String Intern Pool)：
- 存储在堆中。
- 使用 String.intern() 方法时，如果池中已经包含该字符串，则返回池中的字符串引用；否则，将该字符串添加到池中并返回它的引用。

字符串常量池

在字符串常量池中，通过 String.intern() 方法将字符串添加到常量池。如果某个字符串常量在运行过程中不再被引用，则在垃圾回收时会被回收。

public class ConstantPoolGC {
    public static void main(String[] args) {
        // 创建大量字符串，迫使字符串常量池进行回收
        for (int i = 0; i < 10000; i++) {
            String str = new StringBuilder("str").append(i).toString();
            str.intern();
        }

        // 触发垃圾回收
        System.gc();

        // 再次创建相同的字符串，检查是否重新加入常量池
        String str1 = new StringBuilder("str").append(9999).toString();
        String str2 = str1.intern();

        System.out.println(str1 == str2); // true or false, depending on whether the string was collected
    }
}

在这个示例中：

创建大量字符串并使用 intern() 方法将它们加入字符串常量池。
调用 System.gc() 触发垃圾回收，期望部分未被引用的字符串常量被回收。
重新创建一个之前加入常量池的字符串，并检查它是否仍然在常量池中。

总结

在 JDK 1.8 及之后，常量池移到了堆中，常量的回收依赖于垃圾回收器的可达性分析机制。当一个常量在运行过程中不再被引用时，垃圾回收器会在垃圾回收周期中将其回收。通过这种机制，JVM 能够有效地管理和回收废弃常量。

jdk1.8为什么要将常量池移到堆中

永久代空间的局限性：
- 永久代的大小是固定的，容易出现内存不足的情况，尤其是在大量使用动态代理、大量生成类的应用中。
- 将常量池移到堆中，堆的大小可以动态调整，解决了永久代空间不足的问题。
统一内存管理：
- 将常量池和其他对象统一放在堆中，简化了内存管理。
- 便于垃圾回收器统一管理和优化。
JDK 1.8 之后，垃圾回收器在堆中管理常量池，包括字符串常量池和运行时常量池。垃圾回收器通过以下机制判断一个常量是否是废弃常量：
1. 可达性分析 (Reachability Analysis)：
  - 从 GC Roots 开始，进行可达性分析，遍历所有可达对象。
  - 对于字符串常量池，GC Roots 包括系统类加载器加载的类、线程栈中的变量等。
  - 如果一个常量没有任何引用链连接到 GC Roots，则该常量被视为不可达，即废弃常量。
2. 垃圾回收周期：
  - 当进行垃圾回收时，垃圾回收器会标记所有可达的对象和常量。
  - 清理阶段会回收所有未被标记的对象和常量。

如何判断一个类是无用的类

判断一个类是否是无用的类主要依赖于垃圾回收机制以及类加载器的工作原理。无用的类是指在 JVM 运行期间已经没有任何实例存在，并且不再被任何地方引用的类。以下是详细的判断方法和具体机制。

一个类在以下情况下被认为是无用的：

该类的所有实例都已经被回收，也就是说堆中不存在该类的任何实例。
加载该类的 ClassLoader 也已经被回收。
该类对象的 Class 对象没有任何地方被引用，包括没有通过反射引用该类的方法。

具体判断过程

1. 所有实例都已被回收

当一个类的所有实例都被垃圾回收时，说明没有对象在使用这个类。

2. ClassLoader 被回收

JVM 会回收无用的类加载器（ClassLoader），前提是通过该类加载器加载的所有类都已经无用，并且没有对该类加载器的任何引用。
一般情况下，每个类加载器及其加载的类都与应用生命周期相关联，当应用结束时，这些类加载器和类也会被回收。

3. Class 对象无引用

JVM 会检查该类的 Class 对象是否还被引用，如果没有引用，说明没有代码会再访问该类。

触发条件和垃圾回收

JVM 的垃圾回收器会根据上述标准在进行垃圾回收时自动判断并回收无用的类。这通常是在 Full GC（全局垃圾回收）期间进行的。JVM 会在 Full GC 时对方法区进行扫描和整理。

public class ClassUnloadingDemo {
    public static void main(String[] args) {
        // 创建一个类加载器
        MyClassLoader classLoader = new MyClassLoader();
        try {
            // 加载类
            Class<?> clazz = classLoader.loadClass("Test");
            // 创建类的实例
            Object instance = clazz.newInstance();
            // 使用类的实例（这里假设有一些操作）
            System.out.println(instance.getClass().getName());

            // 将类加载器置为空，帮助垃圾回收
            classLoader = null;
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 进行垃圾回收
        System.gc();

        // 让主线程等待一段时间，以便观察类是否被卸载
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 自定义类加载器
class MyClassLoader extends ClassLoader {
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        if ("Test".equals(name)) {
            // 自定义加载类的方式
            byte[] classData = loadClassData(name);
            return defineClass(name, classData, 0, classData.length);
        }
        return super.loadClass(name);
    }

    private byte[] loadClassData(String className) {
        // 这里可以实现自定义的类加载方式，比如从文件或网络加载
        // 为了简单，这里返回一个空数组（假设 Test 类已经在classpath中）
        return new byte[0];
    }
}

在这个示例中：

MyClassLoader 是一个自定义类加载器，用于加载类 Test。
在 main 方法中，加载 Test 类并创建其实例，然后将类加载器置为 null。
调用 System.gc() 触发垃圾回收，并使主线程等待一段时间，以观察类是否被卸载。

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

1.标记-清除算法

特点：

步骤：标记阶段和清除阶段。
- 标记阶段：标记所有可达对象。
- 清除阶段：清除所有未标记对象。
优点
- 实现简单。
- 不需要移动对象，避免了对象的移动开销。
缺点
- 会产生大量不连续的内存碎片。
- 清除阶段的效率较低。

2.复制算法

步骤：将内存分成两块，每次只使用其中的一块。

当使用的内存块满时，将存活的对象复制到另一块，然后清空当前使用的内存块。

优点：

内存分配效率高，只需线性分配内存。
不会产生内存碎片。

缺点：

需要双倍的内存空间。
对于存活率较高的对象，复制开销较大。

新生代中的两个幸存者区就是为了实现该算法。

3.标记-整理算法

特点：

步骤：标记阶段和整理阶段。
- 标记阶段：标记所有可达对象。
- 整理阶段：将所有存活的对象向一端移动，清理端边界外的内存。
优点
- 不会产生内存碎片。
缺点
- 整理阶段的开销较大，需要移动对象。
- 不适合高频率执行

一般当老年代空间不足时，会触发一次FullGC,这时就会碎片整理工作

4.分代收集算法

特点：

基于对象的生命周期进行优化，将堆内存划分为几代（通常为新生代和老年代）。
- 新生代：对象存活时间较短，使用复制算法。
- 老年代：对象存活时间较长，使用标记-整理算法或标记-清除算法。
优点
- 结合了不同算法的优点，提高了垃圾回收的效率。
- 新生代回收频繁，但速度快；老年代回收较少，但处理对象多。
缺点
- 需要额外的内存和处理来管理不同的代。

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

HotSpot JVM 将堆内存划分为新生代和老年代的主要原因是基于对象的生命周期和不同阶段对象存活率的差异来优化垃圾收集效率。这种分代收集（Generational Collection）策略有助于减少垃圾回收停顿时间和提高回收效率。

对象生命周期的差异

大多数对象在创建后很快变得不可达
- 新生代（Young Generation）专门用于存放新创建的对象。
- 大多数新对象会很快变成垃圾，这样可以通过频繁地对新生代进行垃圾回收来快速回收这些对象，避免它们进入老年代。
少数对象存活时间较长
- 老年代（Old Generation）用于存放经过多次新生代回收仍然存活的对象。
- 这些对象存活时间较长，垃圾回收频率较低，但每次回收会涉及更多对象。

提高垃圾回收效率

新生代回收效率高
- 新生代通常使用复制算法（Copying），将内存划分为 Eden 区和两个 Survivor 区。
- 每次垃圾回收只扫描存活时间短的对象，将它们复制到 Survivor 区或提升到老年代，清理整个 Eden 区。
- 复制算法效率高，且不会产生碎片。
老年代回收效率较低但较少
- 老年代回收通常使用标记-整理算法（Mark-Compact）或标记-清除算法（Mark-Sweep）。
- 标记-整理算法将存活对象向一端移动，整理内存以避免碎片，但开销较大。
- 标记-清除算法直接清除不可达对象，可能产生碎片，但适合于老年代对象存活时间长、回收频率低的特点。

减少垃圾回收停顿时间

减少全堆扫描
- 分代收集避免了每次垃圾回收都扫描整个堆，只需扫描新生代或老年代，大大减少了每次回收的工作量。
优化停顿时间
- 新生代回收（Minor GC）频繁但每次停顿时间短。
- 老年代回收（Major GC 或 Full GC）较少发生，尽量减少其对应用响应时间的影响。

新生代和老年代的具体划分

新生代
- 通常占堆内存的1/3左右。
- 分为三个区域：Eden 区和两个 Survivor 区（S0、S1）。
- 大部分新对象分配在 Eden 区，当 Eden 区满时触发 Minor GC，存活对象复制到 Survivor 区。
老年代
- 占堆内存的大部分。
- 存放经过多次 Minor GC 后仍然存活的对象。
- 使用标记-整理或标记-清除算法进行回收。

常见的垃圾回收器有哪些？

1. Serial收集器

目标：单线程执行的垃圾回收器，适用于小型或者单线程应用。
特点：简单高效，适合于在单核处理器或者简单应用场景下使用。

2. Parallel收集器

目标：多线程执行的垃圾回收器，用于提高垃圾收集的效率。
特点：会利用多个 CPU 核心来并行地进行垃圾回收，适合于多核处理器和对响应时间要求不是特别严格的应用场景。

3. CMS收集器 (Concurrent Mark-Sweep)

目标：以减少垃圾收集停顿时间为主要目标的收集器。
特点：采用并发的方式进行大部分的垃圾收集工作，减少应用程序的停顿时间。但是在并发执行过程中可能会产生碎片。

4. G1收集器 (Garbage-First)

目标：将整个堆划分为多个大小相等的区域，以便于更快速、更可预测的进行垃圾回收。
特点：通过并行和并发的方式执行垃圾回收，尽可能缩短停顿时间，并可以控制在预期的时间内完成垃圾回收。

5. ZGC收集器 (Z Garbage Collector)

目标：专注于处理大内存和低延迟的场景。
特点：使用了读屏障和染色指针等技术，以及并发处理的方式来减少垃圾收集的停顿时间，适合需要较低延迟和较大堆内存的应用。

6. Shenandoah收集器

目标：减少垃圾收集的停顿时间，特别适用于需要更低延迟和更可控停顿时间的大内存堆。
特点：通过并发的方式来执行整个垃圾收集过程，可以在不同阶段对堆进行并发清理，以减少应用程序的停顿时间。

7. Epsilon收集器

目标：实现一种“无操作”的垃圾回收器，用于特定的测试和性能基准测试场景。
特点：它实际上并不执行任何垃圾回收，对所有的分配请求都直接分配内存，适用于不需要垃圾回收功能的测试场景。

选择垃圾回收器的考虑因素包括：

应用场景：不同的垃圾回收器适用于不同的应用场景，如响应时间要求、吞吐量要求、堆大小等。
系统配置：硬件配置（CPU 核心数、内存大小）会影响选择合适的垃圾回收器。
性能需求：对于响应时间和吞吐量的具体需求，不同的垃圾回收器会有不同的表现。

介绍一下 CMS,G1 收集器。

CMS收集器 (Concurrent Mark-Sweep)

CMS（Concurrent Mark-Sweep）收集器是 Java 虚拟机中专注于减少垃圾收集停顿时间的一种垃圾回收器。它主要针对老年代进行并发的标记和清理操作，以尽可能减少应用程序的停顿时间。

工作原理：

初始标记（Initial Mark）：暂停所有应用线程(STW,STOP THE WORLD)，标记根对象和直接与根对象关联的对象，以快速标记出需要回收的对象。
并发标记（Concurrent Mark）：同时运行于应用程序的线程之上，标记所有可达对象，包括从根对象可达的对象以及在并发标记过程中新创建的对象。（一边进程，一边标记，会有错误）
重新标记（Remark）：为了处理在并发标记过程中有变动的对象，重新暂停应用线程(STW)，标记发生变动的对象，确保标记的完整性。
并发清除（Concurrent Sweep）：同时运行于应用程序的线程之上，清理未标记的对象，释放空间。

特点：

减少停顿时间：CMS 主要目标是减少垃圾收集的停顿时间，通过并发标记和清理操作，在大部分时间内允许应用程序线程和垃圾回收线程并发执行。
内存碎片问题：由于并发清理过程中不会对对象进行移动或整理，可能会导致内存碎片问题，进而影响长时间运行的稳定性。
适用场景：适合对响应时间要求较高的应用场景，如 Web 应用服务端，但不适合内存非常大且频繁 Full GC 的应用。

G1收集器 (Garbage-First)

G1（Garbage-First）收集器是 JDK 7 引入的一种面向服务端应用的垃圾回收器，它通过将整个堆分割为多个区域来更高效地管理和回收内存。

如果虚拟机频繁的切换用户的工作，把更多的时间用来做GC，吞吐量就下降了

工作原理：

区域划分（Region-based）：将整个堆划分为多个大小相等的区域（Region），包括年轻代和老年代，每个区域可以是 Eden 区、Survivor 区或者老年代。区域不再是物理上连续的空间。谁用乐新空间，新空间就属于哪个区。
并行标记（Concurrent Marking）：采用多线程并行标记的方式，标记所有存活的对象。
混合收集（Mixed Collection）：根据堆内存使用情况和垃圾回收的需求，选择部分区域进行收集，以减少全局性的停顿时间。
逐步清理（Incremental Cleaning）：通过逐步清理未使用的区域来释放内存，避免长时间的垃圾回收停顿。

特点：

高效的垃圾回收：通过分区管理和并行处理，G1 收集器可以在更短的时间内实现较为可预测的停顿时间，避免了 Full GC 长时间停顿的问题。
自适应的收集策略：根据应用程序的内存需求和垃圾回收的情况，G1 收集器能够动态调整和优化垃圾回收的行为，提供更好的性能和稳定性。
适用场景：适合需要低延迟和高吞吐量的大内存应用，尤其是那些需要更可控的垃圾回收停顿时间的应用场景。

比较和选择：

CMS vs G1：CMS 收集器更注重减少老年代的停顿时间，适合对响应时间要求较高的应用；而 G1 收集器在综合考虑吞吐量和停顿时间的情况下，更适合大堆内存、多核处理器、需要可预测停顿时间的应用。G1运用三色标记法解决了CMS中错标的问题。
适用性：选择适当的垃圾收集器需考虑应用的具体需求，包括内存大小、处理器核数、响应时间要求等因素，以优化应用程序的性能和稳定性。

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

在 Java 的垃圾回收（Garbage Collection，GC）过程中，有两种主要类型的垃圾回收操作：Minor GC（年轻代GC）和 Full GC（全局GC，或者老年代GC）。它们在目标、影响范围和触发条件等方面有所不同。

Minor GC（年轻代GC）

目标：主要清理年轻代（Young Generation）中的垃圾对象。
影响范围：只涉及年轻代区域，包括 Eden 区和两个 Survivor 区。
触发条件：当年轻代空间不足时，触发 Minor GC。通常情况下，对象在 Eden 区被创建，如果对象存活并且经过一定次数的垃圾回收后仍然存活，会被移到 Survivor 区。当 Survivor 区也不足时，会触发一次 Minor GC。

Full GC（全局GC，或者老年代GC）

目标：清理整个堆内存，包括年轻代和老年代，甚至是方法区（Metaspace）。
影响范围：全局性的垃圾回收，涉及整个堆内存的清理。
触发条件
- 当老年代空间不足时，会触发 Full GC。老年代的对象通常是年龄较大的对象，生命周期较长。
- 当方法区（Metaspace）空间不足时，也会触发 Full GC。方法区存储类的元数据信息、静态变量、常量等，当加载的类过多或者大量动态生成类时，可能会导致方法区溢出。

主要区别

清理范围：
- Minor GC：只清理年轻代的内存空间，即 Eden 区和 Survivor 区。
- Full GC：清理整个堆内存，包括年轻代和老年代，有时也包括方法区（Metaspace）。
影响对象：
- Minor GC：通常影响年龄较轻的对象，因为年轻代主要存放生命周期较短的对象。
- Full GC：影响整个堆内存中的对象，包括生命周期较长的对象和元数据信息。
触发条件：
- Minor GC：当年轻代空间不足时触发，频率比较高，一般不会导致应用程序停顿太久。
- Full GC：通常在老年代空间不足或者方法区空间不足时触发，由于需要清理整个堆内存，因此会导致较长的停顿时间，影响应用程序的响应性能。