Java垃圾回收机制概述 - 摩柯技术社区

Java垃圾回收机制的基本概念

在Java编程中，垃圾回收（Garbage Collection，简称GC）是自动管理内存的重要机制。与C和C++等语言不同，Java程序员无需手动释放不再使用的内存。当对象不再被程序使用时，垃圾回收器会自动识别并回收其所占用的内存空间。

在Java运行时环境（JRE）中，堆（Heap）是对象分配内存的主要区域。随着程序的运行，对象不断被创建和使用，堆空间会逐渐被占用。如果没有垃圾回收机制，堆内存最终会被耗尽，导致程序因内存不足而崩溃。垃圾回收器通过定期扫描堆内存，识别出那些不再被引用的对象，将其占用的内存标记为可回收，并在适当的时候释放这些内存空间，供新的对象使用。

垃圾回收的触发时机

垃圾回收的触发时机并不是完全由程序员控制的，而是由JVM根据堆内存的使用情况来决定。通常有以下几种情况会触发垃圾回收：

显式调用：可以通过调用System.gc()方法来建议JVM执行垃圾回收，但这仅仅是一个建议，JVM并不一定会立即执行。例如：

public class GCExample {
    public static void main(String[] args) {
        System.out.println("Before System.gc()");
        System.gc();
        System.out.println("After System.gc()");
    }
}

在上述代码中，System.gc()方法被调用，但JVM可能会选择不立即执行垃圾回收，具体行为取决于JVM的实现和当前系统状态。 2. 内存不足：当JVM尝试分配新对象，但堆内存空间不足时，会触发垃圾回收。JVM希望通过回收不再使用的对象来释放足够的内存空间，以满足新对象的分配需求。例如，下面的代码通过不断创建大对象来模拟内存不足的情况：

public class MemoryExhaustionExample {
    public static void main(String[] args) {
        try {
            while (true) {
                byte[] largeArray = new byte[1024 * 1024]; // 创建1MB的数组
            }
        } catch (OutOfMemoryError e) {
            System.out.println("Caught OutOfMemoryError: " + e.getMessage());
        }
    }
}

在这个例子中，随着循环不断创建大数组，堆内存最终会耗尽，触发垃圾回收。如果垃圾回收后仍然无法满足内存需求，程序将抛出OutOfMemoryError。 3. 达到一定阈值：JVM会监控堆内存的使用情况，当堆内存的使用率达到一定阈值时，会自动触发垃圾回收。这个阈值的具体数值取决于JVM的实现和配置。例如，在某些JVM实现中，如果老年代（Old Generation，后面会详细介绍）的使用率达到92%，就会触发垃圾回收。

垃圾回收算法

标记 - 清除算法（Mark - Sweep Algorithm）
- 基本原理：该算法分为两个阶段，标记阶段和清除阶段。在标记阶段，垃圾回收器从根对象（如栈中的局部变量、静态变量等）开始遍历，标记所有被引用的对象。然后在清除阶段，垃圾回收器扫描整个堆内存，回收所有未被标记的对象，即垃圾对象。
- 优点：实现相对简单，不需要额外的空间来复制对象。
- 缺点：会产生大量的内存碎片。例如，假设有一个对象A和一个对象B，A先被分配内存，然后B被分配在A之后。如果A先成为垃圾对象被回收，B继续存在，那么A占用的空间就成为了碎片。随着时间推移，内存碎片会越来越多，导致后续大对象无法分配到连续的内存空间，即使堆内存总体上还有足够的空闲空间。
- 代码模拟：虽然Java实际的垃圾回收机制较为复杂，我们可以简单模拟标记 - 清除算法的逻辑：

class MemoryBlock {
    boolean isUsed;
    MemoryBlock next;

    MemoryBlock(boolean isUsed) {
        this.isUsed = isUsed;
    }
}

class MarkSweepGC {
    MemoryBlock head;

    void allocate() {
        MemoryBlock newBlock = new MemoryBlock(true);
        newBlock.next = head;
        head = newBlock;
    }

    void mark() {
        // 这里简单假设栈中有一个引用指向头节点
        MemoryBlock current = head;
        while (current != null) {
            current.isUsed = true;
            current = current.next;
        }
    }

    void sweep() {
        MemoryBlock current = head;
        MemoryBlock prev = null;
        while (current != null) {
            if (!current.isUsed) {
                if (prev == null) {
                    head = current.next;
                } else {
                    prev.next = current.next;
                }
            } else {
                prev = current;
            }
            current = current.next;
        }
    }
}

复制算法（Copying Algorithm）
- 基本原理：将堆内存分为两个相等的区域，每次只使用其中一个区域。当一个区域的内存使用满了，垃圾回收器将该区域中所有存活的对象复制到另一个区域，然后清空原来的区域。例如，将区域A中的存活对象复制到区域B，然后把区域A整个清空。
- 优点：不会产生内存碎片，而且复制过程中可以对对象进行整理，使对象在内存中连续存放，提高内存访问效率。同时，由于只需复制存活对象，回收速度相对较快。
- 缺点：需要额外的空间，因为堆内存被分成了两个区域，实际可用内存只有一半。例如，如果堆内存总大小为100MB，采用复制算法，每次实际可用内存只有50MB。
- 适用场景：适用于新生代（Young Generation，Java堆内存的一部分，后面会详细介绍），因为新生代中对象的存活率通常较低，复制操作的成本相对较小。
标记 - 整理算法（Mark - Compact Algorithm）
- 基本原理：标记 - 整理算法也是先进行标记阶段，标记出所有存活的对象。然后在整理阶段，将所有存活的对象向一端移动，最后直接清理掉边界以外的内存空间。例如，假设有对象A、B、C，其中B是垃圾对象，标记后将A和C向一端移动，使它们紧密排列，然后清理掉原来B占用的空间。
- 优点：避免了标记 - 清除算法产生的内存碎片问题，同时不像复制算法那样需要额外的大量空间。
- 缺点：整理过程中移动对象的操作成本较高，尤其是对象数量较多时，会影响垃圾回收的性能。
- 适用场景：适用于老年代（Old Generation），因为老年代中对象存活率较高，复制算法的空间浪费问题较为突出，而标记 - 整理算法更适合这种场景。

Java堆内存结构与垃圾回收

Java的堆内存主要分为三个部分：新生代（Young Generation）、老年代（Old Generation）和永久代（Perm Generation，在Java 8及之后被元空间Metaspace取代）。

新生代
- 结构：新生代又进一步分为一个伊甸园区（Eden Space）和两个幸存者区（Survivor Space，通常称为Survivor 0和Survivor 1）。
- 对象分配与回收：新创建的对象通常首先分配在伊甸园区。当伊甸园区内存满时，会触发Minor GC（新生代垃圾回收）。在Minor GC过程中，伊甸园区中存活的对象会被复制到其中一个幸存者区（假设是Survivor 0），伊甸园区被清空。然后，下次伊甸园区满时再次触发Minor GC，伊甸园区和Survivor 0中存活的对象会被复制到Survivor 1，Survivor 0被清空，同时对象的年龄（对象经历垃圾回收的次数）会增加。当对象的年龄达到一定阈值（通常是15，可通过参数调整），对象会被晋升到老年代。例如：

public class YoungGenerationExample {
    public static void main(String[] args) {
        byte[] smallObject = new byte[1024 * 100]; // 100KB对象，分配在伊甸园区
        byte[] largeObject = new byte[1024 * 1024 * 2]; // 2MB对象，可能直接分配到老年代（根据JVM配置）
    }
}

在上述代码中，smallObject大概率会分配在伊甸园区，当伊甸园区满触发Minor GC时，若smallObject存活，会被复制到幸存者区。而largeObject由于较大，可能直接分配到老年代（具体取决于JVM的对象分配策略和参数配置）。 2. 老年代 - 作用：老年代用于存放经过多次Minor GC后仍然存活的对象。随着程序的运行，一些对象在新生代中经历了多次垃圾回收后仍然存活，它们会被晋升到老年代。老年代的空间通常比新生代大，因为老年代中的对象存活时间较长，不需要频繁回收。 - 垃圾回收：当老年代的内存使用率达到一定阈值时，会触发Major GC（也称为Full GC），对老年代进行垃圾回收。Major GC的速度通常比Minor GC慢，因为老年代中对象数量多且存活率高，回收成本较大。例如，一些长期存活的缓存对象、数据库连接对象等通常会在老年代中。 3. 永久代（Java 8之前）与元空间（Java 8及之后） - 永久代：在Java 8之前，永久代用于存放类的元数据信息，如类的结构、方法信息、常量池等。永久代的大小在启动JVM时可以通过参数设置，如-XX:MaxPermSize。当永久代空间不足时，会抛出OutOfMemoryError: PermGen space错误。 - 元空间：从Java 8开始，永久代被元空间取代。元空间使用本地内存（Native Memory），而不是堆内存，这使得元空间的大小不再受限于堆内存的大小。元空间的大小可以动态扩展，只要系统有足够的本地内存。例如，在Java 8中，加载大量的类时，元空间会根据需要自动扩展，而不会像永久代那样容易出现空间不足的问题。

垃圾回收器

Serial垃圾回收器
- 特点：Serial垃圾回收器是最基本、最古老的垃圾回收器。它采用单线程进行垃圾回收，在进行垃圾回收时，会暂停所有的用户线程（Stop - The - World，简称STW）。优点是实现简单，内存管理开销小，适用于单核CPU环境下的小型应用程序。例如，在一些嵌入式设备或者对内存和CPU资源要求不高的小型Java程序中，Serial垃圾回收器可能是一个不错的选择。
- 启动参数：可以通过-XX:+UseSerialGC参数来启用Serial垃圾回收器。
Parallel垃圾回收器
- 特点：Parallel垃圾回收器也被称为吞吐量优先垃圾回收器。它采用多线程进行垃圾回收，同样会在垃圾回收时暂停用户线程。与Serial垃圾回收器相比，Parallel垃圾回收器利用多线程的优势，能够在更短的时间内完成垃圾回收，从而提高系统的吞吐量（系统在单位时间内处理的任务量）。适用于对吞吐量要求较高的应用场景，如大规模数据处理、科学计算等。
- 启动参数：可以通过-XX:+UseParallelGC参数启用Parallel垃圾回收器进行新生代垃圾回收，通过-XX:+UseParallelOldGC参数启用Parallel垃圾回收器进行老年代垃圾回收。
CMS（Concurrent Mark Sweep）垃圾回收器
- 特点：CMS垃圾回收器是一种以获取最短回收停顿时间为目标的垃圾回收器。它采用多线程并发执行垃圾回收，尽量减少垃圾回收过程中对用户线程的影响。CMS垃圾回收过程分为四个阶段：初始标记（Initial Mark）、并发标记（Concurrent Mark）、重新标记（Remark）和并发清除（Concurrent Sweep）。初始标记和重新标记阶段仍然需要暂停用户线程，但时间较短，而并发标记和并发清除阶段可以与用户线程并发执行。适用于对响应时间要求较高的应用，如Web应用程序，因为它能尽量减少垃圾回收对用户请求的影响。
- 缺点：CMS垃圾回收器会产生内存碎片，因为它采用标记 - 清除算法。而且在并发清除阶段，用户线程继续运行会不断产生新对象，可能导致在垃圾回收过程中需要分配新的内存空间，而由于内存碎片问题，可能无法及时分配，从而导致失败，这时会临时启用Serial Old垃圾回收器进行垃圾回收，这会导致较长的停顿时间。
- 启动参数：可以通过-XX:+UseConcMarkSweepGC参数启用CMS垃圾回收器。
G1（Garbage - First）垃圾回收器
- 特点：G1垃圾回收器是Java 7u4之后引入的一种全新的垃圾回收器。它将堆内存划分为多个大小相等的Region，每个Region可以扮演伊甸园区、幸存者区或者老年代的角色。G1垃圾回收器在回收时，会优先回收垃圾最多的Region，即“垃圾优先”。它采用多线程并发执行垃圾回收，并且能够预测垃圾回收的停顿时间。G1垃圾回收器适用于大内存、多核CPU的应用场景，既兼顾了吞吐量，又能保证较短的停顿时间，逐渐成为Java应用中广泛使用的垃圾回收器。
- 启动参数：可以通过-XX:+UseG1GC参数启用G1垃圾回收器。

调优垃圾回收机制

监控垃圾回收
- 工具：可以使用JDK自带的工具如jstat来监控垃圾回收的相关信息。例如，通过jstat -gc <pid> <interval> <count>命令可以查看指定进程ID（<pid>）的垃圾回收统计信息，<interval>表示统计信息的输出间隔时间（单位为毫秒），<count>表示输出的次数。例如，jstat -gc 1234 1000 10表示每1000毫秒输出一次进程ID为1234的垃圾回收统计信息，共输出10次。输出信息包括新生代、老年代的内存使用情况、垃圾回收次数、垃圾回收耗时等。
- 日志：通过设置JVM参数开启垃圾回收日志，如-XX:+PrintGCDetails -XX:+PrintGCTimeStamps，JVM会在每次垃圾回收时输出详细的日志信息，包括垃圾回收发生的时间、垃圾回收器的类型、回收前后各代内存的使用情况等。这些日志信息对于分析垃圾回收性能非常有帮助。
调整堆内存大小
- 新生代与老年代比例：可以通过-Xmn参数设置新生代的大小，从而间接调整新生代与老年代的比例。例如，-Xmn2g表示将新生代大小设置为2GB。合理调整新生代与老年代的比例可以影响垃圾回收的频率和效率。如果新生代设置过大，Minor GC的频率会降低，但每次Minor GC的时间可能会增加；如果新生代设置过小，Minor GC的频率会增加，但每次Minor GC的时间可能会减少。
- 堆内存总大小：通过-Xms和-Xmx参数设置堆内存的初始大小和最大大小。例如，-Xms4g -Xmx8g表示堆内存初始大小为4GB，最大大小为8GB。如果堆内存设置过小，可能会频繁触发垃圾回收，甚至导致OutOfMemoryError；如果堆内存设置过大，虽然可以减少垃圾回收的频率，但可能会占用过多的系统资源，影响系统的整体性能。
选择合适的垃圾回收器
- 应用场景分析：根据应用程序的特点选择合适的垃圾回收器。如果应用程序对吞吐量要求较高，如大规模数据处理任务，可以选择Parallel垃圾回收器；如果应用程序对响应时间要求较高，如Web应用程序，CMS或G1垃圾回收器可能更合适。对于单核CPU或者对内存管理开销要求较低的小型应用程序，Serial垃圾回收器可能是一个简单有效的选择。
- 性能测试：在实际应用中，可以通过性能测试来评估不同垃圾回收器对应用程序性能的影响。通过模拟实际的业务场景，对应用程序在不同垃圾回收器配置下进行性能测试，比较吞吐量、响应时间、内存使用等指标，从而选择最适合的垃圾回收器。

总结垃圾回收机制的注意事项

避免频繁创建和销毁大对象：频繁创建和销毁大对象会增加垃圾回收的负担。例如，在循环中不断创建大数组对象，会导致伊甸园区频繁满，从而频繁触发Minor GC。如果这些大对象存活时间较短，应该尽量复用对象，而不是每次都创建新的对象。
注意对象的生命周期：合理控制对象的生命周期，及时释放不再使用的对象引用。例如，在使用完数据库连接对象后，应该及时关闭连接并将引用置为null，这样垃圾回收器才能及时回收该对象占用的内存。否则，即使对象不再被使用，但由于仍然存在引用，垃圾回收器无法回收其内存。
理解不同垃圾回收器的特点：不同的垃圾回收器适用于不同的应用场景，开发人员应该深入理解各种垃圾回收器的特点，根据应用程序的需求选择合适的垃圾回收器。同时，要注意不同垃圾回收器的默认参数可能不适合特定的应用场景，需要根据实际情况进行调整。

通过深入理解Java垃圾回收机制的原理、算法、堆内存结构、垃圾回收器以及调优方法，开发人员可以更好地编写高效、稳定的Java应用程序，避免因内存管理不当导致的性能问题和内存溢出错误。在实际开发中，结合应用程序的特点和需求，合理配置垃圾回收相关参数，选择合适的垃圾回收器，是优化Java应用程序性能的重要手段。同时，持续监控和分析垃圾回收的情况，根据实际运行情况进行调整，也是保障应用程序性能的关键。希望本文所介绍的内容能帮助读者在Java开发中更好地利用垃圾回收机制，提升程序的性能和稳定性。