返回专栏
· 19 分钟阅读

垃圾回收(Garbage Collection,GC)


一、什么是垃圾回收?

垃圾回收(Garbage Collection,简称 GC)是运行时系统自动管理内存的一种机制。

在程序运行过程中,程序会不断创建对象、分配内存、修改对象之间的引用关系。当某些对象不再被程序使用时,它们占用的内存就可能被回收并重新利用。

在手动内存管理模型中,开发者通常需要显式申请和释放内存,例如 C 语言中的 malloc() 和 free()。

而在采用自动垃圾回收机制的语言或运行时中,GC 会负责识别不再需要的对象,并在适当时机回收其内存。

例如:

public class Main {
    public static void main(String[] args) {
        Object obj = new Object();

        obj = null;
    }
}

执行 obj = null 后,原来创建的对象不再被局部变量 obj 引用。

如果不存在其他有效引用,该对象就可能成为垃圾回收的候选对象。

需要注意:

  • 对象不再被引用,不代表内存立即释放。
  • 对象符合回收条件,不代表 GC 会立即执行。
  • GC 何时运行,通常由运行时系统决定。
  • GC 主要管理受其管辖的内存,并不意味着程序中的所有资源都会自动释放。

二、为什么需要垃圾回收?

内存管理是程序运行时的重要职责。

如果内存管理不当,可能出现内存泄漏、悬空指针、重复释放等问题。

1. 手动内存管理的复杂性

以 C 语言为例:

#include <stdlib.h>

int main() {
    int *ptr = malloc(sizeof(int));

    if (ptr == NULL) {
        return 1;
    }

    *ptr = 100;

    free(ptr);

    return 0;
}

开发者需要确保:

  • 内存分配成功后正确使用。
  • 不再使用时及时释放。
  • 同一块内存不能重复释放。
  • 释放后不能继续访问。
  • 所有可能的执行路径都正确处理资源。

如果遗漏释放操作,就可能产生内存泄漏。

如果释放后继续访问,就可能产生 Use-After-Free。

如果重复释放同一块内存,就可能导致 Double Free。

2. GC 解决的问题

GC 通过自动识别不可达对象,降低内存管理的复杂度。

问题 手动内存管理 自动垃圾回收
内存申请 开发者或运行时 通常由运行时分配
内存释放 开发者负责 GC 自动回收受管理对象
内存泄漏 容易因遗漏释放产生 仍可能因对象持续可达而发生
悬空引用 需要开发者防范 受管理对象通常由 GC 保证引用安全
重复释放 需要开发者防范 通常不需要显式释放受管理对象
内存管理成本 开发者承担较多责任 运行时承担回收成本

GC 并不是完全消除内存问题,而是将一部分内存管理责任交给运行时。

例如,即使使用 GC,如果程序持续将不再需要的数据保存在全局集合中,这些对象仍然可能保持可达,最终形成逻辑意义上的内存泄漏。

三、GC 的核心原理:对象可达性

GC 最核心的问题不是判断对象是否正在执行,而是判断对象是否仍然可以从程序规定的起点访问到。

这个起点集合通常称为 GC Roots(垃圾回收根)。

1. 什么是 GC Roots?

GC Roots 是垃圾回收器判断对象是否存活时使用的一组根引用。

常见的根包括:

  • 当前线程栈帧中的局部变量引用。
  • 活跃线程的引用。
  • 静态变量引用。
  • JNI 等本地接口持有的引用。
  • 虚拟机内部的特殊引用。
  • 运行时明确登记的其他根对象。

具体根集合取决于语言运行时和 GC 实现。

例如,在 Java 虚拟机中,GC Roots 是可达性分析的重要起点。

2. 什么是对象可达性?

假设程序中存在以下对象引用关系:

GC Root
   |
   v
对象 A
   |
   v
对象 B
   |
   v
对象 C

从 GC Root 出发,可以通过引用访问到 A、B、C,因此这些对象都属于可达对象。

如果对象 D 没有任何从 GC Root 出发的引用路径,那么 D 就属于不可达对象。

3. 可达性分析过程

flowchart TB
    A["确定 GC Roots"] --> B["从根对象开始遍历引用"]
    B --> C["标记可达对象"]
    C --> D["检查堆中的其他对象"]
    D --> E{"对象是否被标记"}
    E -->|"是"| F["保留对象"]
    E -->|"否"| G["判定为不可达候选对象"]
    G --> H["进入后续回收处理"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

这里有一个重要概念:

不可达不等于对象没有被任何变量引用,而是不存在从 GC Roots 出发的有效引用路径。

一个对象可能仍然被其他对象引用,但如果整个引用链都无法从 GC Roots 到达,这些对象仍然可能被整体回收。

4. 循环引用为什么可以被 GC 回收?

这是理解 GC 与引用计数的重要区别。

例如:

class Node {
    Node next;
}

public class Main {
    public static void main(String[] args) {
        Node a = new Node();
        Node b = new Node();

        a.next = b;
        b.next = a;

        a = null;
        b = null;
    }
}

对象 A 引用对象 B,对象 B 又引用对象 A,形成循环引用。

虽然两个对象之间仍然存在引用,但已经不存在从 GC Roots 到达它们的路径。

因此,基于可达性分析的 GC 可以识别这两个对象均不可达,并将其作为回收候选对象。

这也是追踪式 GC 能够处理循环引用的重要原因。

四、垃圾回收的主要算法

GC 有多种实现算法,不同算法在内存利用率、回收效率、停顿时间和空间开销方面存在不同取舍。

最基础的算法包括:

  1. 标记-清除(Mark-Sweep)。
  2. 标记-整理(Mark-Compact)。
  3. 复制算法(Copying)。
  4. 引用计数(Reference Counting)。

1. 标记-清除算法(Mark-Sweep)

标记-清除是经典的追踪式垃圾回收算法。

它分为两个主要阶段:

标记阶段

从 GC Roots 出发遍历对象引用,将所有可达对象标记为存活。

清除阶段

扫描内存区域,将未被标记的对象所占用的空间回收。

flowchart TB
    A["开始垃圾回收"] --> B["标记阶段"]
    B --> C["从 GC Roots 遍历"]
    C --> D["标记所有可达对象"]
    D --> E["清除阶段"]
    E --> F["扫描堆内存"]
    F --> G["回收未标记对象"]
    G --> H["完成回收"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

优点:

  • 算法原理简单。
  • 不需要移动存活对象。
  • 可以处理循环引用。

缺点:

  • 回收后容易产生内存碎片。
  • 需要扫描对象和内存区域。
  • 标记和清除过程可能带来较明显的执行开销。

内存碎片问题

假设堆内存中存在多个对象:

回收前:

┌──────┬──────┬──────┬──────┬──────┐
│  A   │  B   │  C   │  D   │  E   │
└──────┴──────┴──────┴──────┴──────┘

回收 B、D 后:

┌──────┬──────┬──────┬──────┬──────┐
│  A   │ 空闲 │  C   │ 空闲 │  E   │
└──────┴──────┴──────┴──────┴──────┘

虽然存在空闲内存,但它们可能分散在不同位置。

当程序需要分配一块较大的连续内存时,即使空闲空间总量足够,也可能无法直接满足分配请求。

2. 标记-整理算法(Mark-Compact)

标记-整理算法在标记存活对象后,将存活对象移动到连续的内存区域。

原有的碎片空间被整理为连续空闲空间。

flowchart TB
    A["开始回收"] --> B["标记存活对象"]
    B --> C["确定对象移动位置"]
    C --> D["移动存活对象"]
    D --> E["更新对象引用"]
    E --> F["整理空闲内存"]
    F --> G["完成回收"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

优点:

  • 可以消除外部内存碎片。
  • 空闲内存更加连续。
  • 有利于后续内存分配。

缺点:

  • 移动对象需要额外开销。
  • 对象移动后需要更新引用。
  • 在移动过程中需要保证对象引用关系正确。

需要注意,对象移动并不意味着所有程序都必须更新普通指针。具体实现可能使用对象引用更新、句柄、间接寻址或其他机制来维持引用有效性。

3. 复制算法(Copying)

复制算法将堆内存划分为两个区域:

  • From Space:当前使用区域。
  • To Space:目标区域。

回收时,将 From Space 中存活的对象复制到 To Space,然后交换两个区域的角色。

flowchart TB
    A["当前 From Space"] --> B["识别存活对象"]
    B --> C["复制存活对象到 To Space"]
    C --> D["更新对象引用"]
    D --> E["交换 From 与 To"]
    E --> F["原 From Space 整体变为空闲空间"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

优点:

  • 不会产生传统意义上的外部内存碎片。
  • 存活对象集中分布。
  • 分配空间简单,通常可以通过移动分配指针完成。

缺点:

  • 需要额外的目标空间。
  • 存活对象需要复制。
  • 存活对象较多时,复制成本较高。

复制算法尤其适合存活对象比例较低的内存区域。

4. 引用计数算法(Reference Counting)

引用计数通过记录对象被引用的次数,判断对象是否可以回收。

当对象创建时,引用计数通常初始化为一定值。

每当新增一个有效引用,计数增加;每当一个引用失效,计数减少。

当引用计数降为零时,对象就可以被释放。

例如:

a = []
b = a
c = a

del b
del c

在引用计数模型下,变量 b 和 c 对应的引用被移除后,引用计数会发生变化。

但需要注意,Python 中的具体对象生命周期还受到实现细节、临时引用和运行时机制影响。上述代码仅用于说明引用计数的基本思想。

优点:

  • 对象引用计数归零时,可以较快释放内存。
  • 不一定需要周期性扫描整个对象图。
  • 可以较容易地与部分手动资源管理机制结合。

缺点:

  • 每次引用变化都可能产生计数更新开销。
  • 需要额外空间存储引用计数。
  • 循环引用无法单独通过普通引用计数解决。

循环引用问题

flowchart TB
    A["对象 A<br/>引用计数为 1"] --> B["对象 B<br/>引用计数为 1"]
    B --> A
    C["外部引用失效"] --> D["A、B 仍然互相引用"]
    D --> E["引用计数无法归零"]
    E --> F["需要额外的循环引用检测机制"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

引用计数为 1 的情况只是示意,实际计数取决于对象持有的引用数量。

5. 四种算法对比

算法 核心机制 内存碎片 对象移动 主要问题
标记-清除 标记存活对象,清除不可达对象 可能产生 不需要 内存碎片
标记-整理 标记后移动存活对象 可消除外部碎片 需要 移动和引用更新成本
复制算法 将存活对象复制到另一空间 通常不会产生外部碎片 需要 需要额外空间
引用计数 统计对象引用数量 取决于分配器 不要求 循环引用

实际 GC 通常不是简单使用单一算法,而是根据对象生命周期、堆内存区域和停顿目标组合多种技术。

五、分代垃圾回收(Generational GC)

分代垃圾回收是现代垃圾回收器广泛使用的一种优化策略。

它建立在一个经验性观察之上:

大多数对象的生命周期较短,只有少数对象会长期存活。

这被称为弱代假说(Weak Generational Hypothesis)。

例如:

  • 函数执行过程中创建的临时对象,通常很快失去引用。
  • 请求处理过程中创建的中间数据,可能在请求结束后就不再使用。
  • 全局缓存、长期运行的服务状态等对象,可能持续存活较长时间。

如果每次 GC 都扫描整个堆,就可能浪费大量时间检查长期存活对象。

分代 GC 将对象按照存活时间划分为不同区域,优先回收年轻对象。

1. 年轻代与老年代

在经典分代 GC 模型中,堆通常划分为:

  • 年轻代(Young Generation):存放新创建的对象。
  • 老年代(Old Generation):存放经过多次回收仍然存活的对象。

年轻代内部还可能划分为:

  • Eden 区:主要用于新对象分配。
  • Survivor From:用于保存上一次回收后存活的对象。
  • Survivor To:用于接收本次回收后存活的对象。

2. 对象晋升过程

对象通常先进入年轻代。

如果经过多次年轻代 GC 仍然存活,就可能被提升到老年代。

flowchart TB
    A["创建新对象"] --> B["进入 Eden 区"]
    B --> C["发生 Minor GC"]
    C --> D{"对象是否存活"}
    D -->|"否"| E["回收对象"]
    D -->|"是"| F["复制到 Survivor 区"]
    F --> G["继续经历年轻代 GC"]
    G --> H{"是否达到晋升条件"}
    H -->|"否"| F
    H -->|"是"| I["晋升到老年代"]
    I --> J["参与老年代回收"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style H fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style J fill:#E8EDF2,stroke:#B8C3CE,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

这里的晋升条件可能包括:

  • 对象年龄达到阈值。
  • Survivor 区空间不足。
  • 对象体积超过特定阈值。
  • GC 实现采用的其他自适应策略。

并非所有 GC 都严格采用上述年轻代、老年代和 Survivor 区结构。

3. 分代 GC 为什么高效?

假设堆中存在 100 万个对象,其中 90 万个对象是短生命周期对象。

如果每次回收都扫描全部对象,就需要频繁处理大量长期存活对象。

分代 GC 可以优先扫描年轻代,将回收工作集中在对象死亡率较高的区域。

它的核心思想是:

  • 高频回收年轻对象。
  • 减少对长期存活对象的重复处理。
  • 在必要时执行更大范围的回收。

4. 跨代引用问题

分代 GC 有一个重要挑战:老年代对象可能引用年轻代对象。

例如:

老年代对象 A
     |
     v
年轻代对象 B

如果 GC 只扫描年轻代中的根引用,却忽略老年代到年轻代的引用,就可能错误地回收 B。

因此,GC 需要记录或追踪跨代引用。

常见技术包括:

  • 卡表(Card Table)。
  • 写屏障(Write Barrier)。
  • 记忆集(Remembered Set)。

这些机制可以帮助年轻代 GC 快速确定来自老年代的引用,而不必每次扫描整个老年代。

六、Stop-the-World(STW)与安全点

垃圾回收不仅涉及对象识别,还涉及程序执行过程中的内存状态一致性。

当 GC 需要遍历对象引用、移动对象或更新引用时,必须确保不会因为程序线程同时修改对象关系而导致错误。

一种常见方式是暂停应用程序线程。

这种暂停称为 Stop-the-World,简称 STW。

1. 什么是 STW?

STW 指垃圾回收器在某些阶段暂停应用程序线程,使 GC 能够在相对稳定的状态下完成必要操作。

例如:

flowchart TB
    A["应用程序正常运行"] --> B["GC 请求暂停线程"]
    B --> C["线程到达安全点"]
    C --> D["暂停应用程序线程"]
    D --> E["执行 GC 阶段"]
    E --> F["完成必要的对象处理"]
    F --> G["恢复应用程序线程"]
    G --> H["应用程序继续运行"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

STW 期间,应用程序线程无法继续执行普通业务逻辑,因此会影响程序响应时间。

2. 什么是安全点(Safepoint)?

安全点是运行时能够安全暂停线程并检查其执行状态的位置。

在安全点,运行时通常能够确定:

  • 当前线程正在执行什么代码。
  • 哪些寄存器和栈位置包含对象引用。
  • 当前栈帧结构。
  • 如何安全地遍历线程栈。

安全点是 GC 正确识别对象引用的重要基础。

需要注意,安全点不是任意一条机器指令,也不意味着所有线程随时都可以立即暂停。

3. STW 的性能影响

STW 主要影响:

  • 请求响应时间。
  • 应用程序吞吐量。
  • 实时系统的执行确定性。
  • 延迟敏感型服务的稳定性。

例如,一个在线服务平均响应时间为 20ms,如果 GC 暂停导致某些请求额外等待 200ms,就可能明显影响尾延迟。

因此,GC 优化通常需要在吞吐量、内存占用和停顿时间之间进行权衡。

七、并发垃圾回收与增量垃圾回收

为了减少 STW 时间,现代 GC 引入了并发回收和增量回收机制。

1. 并发 GC(Concurrent GC)

并发 GC 指垃圾回收线程与应用程序线程同时执行。

传统的完全暂停式回收可能需要在较长时间内停止应用程序。

并发 GC 则尝试让部分 GC 阶段与应用程序并行执行。