一、什么是垃圾回收?
垃圾回收(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 有多种实现算法,不同算法在内存利用率、回收效率、停顿时间和空间开销方面存在不同取舍。
最基础的算法包括:
- 标记-清除(Mark-Sweep)。
- 标记-整理(Mark-Compact)。
- 复制算法(Copying)。
- 引用计数(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 阶段与应用程序并行执行。