Appearance
Epsilon GC（无操作垃圾回收器）
概述
Epsilon GC 是 OpenJDK 11 引入的一个实验性垃圾回收器，也被称为"No-Op"（无操作）垃圾回收器。与传统的垃圾回收器不同，Epsilon GC 实际上不执行任何垃圾回收操作，它只负责内存分配，当堆内存耗尽时应用程序会直接崩溃。这种设计看似反常，但在特定场景下具有重要的价值，特别是在性能测试、内存分配研究和短生命周期应用中。
基本特征
核心特点
- 零 GC 开销：完全没有垃圾回收的性能开销
- 纯内存分配器：只负责内存分配，不回收内存
- 极简实现：代码量最少的垃圾回收器
- 确定性行为：行为完全可预测
- 实验性质：主要用于研究和测试
适用场景
- 性能基准测试：测量应用的纯计算性能
- 内存分配研究：分析内存分配模式
- 短生命周期应用：运行时间短，不需要 GC
- 微服务应用：快速启动和关闭的服务
- 批处理任务：一次性处理任务
设计原理
1. 无操作设计
Epsilon GC 的核心设计理念是"什么都不做"：
Epsilon GC 的工作模式：
1. 内存分配：
- 正常分配对象内存
- 维护堆内存指针
- 处理 TLAB（线程本地分配缓冲区）
2. 垃圾回收：
- 不执行任何回收操作
- 不标记对象
- 不清理内存
- 不移动对象
3. 内存耗尽处理：
- 当堆内存耗尽时
- 抛出 OutOfMemoryError
- 应用程序终止
设计优势：
- 零 GC 停顿时间
- 最小的运行时开销
- 完全可预测的行为
- 简单的实现和维护2. 内存管理策略
Epsilon GC 采用最简单的内存管理策略：
内存管理特点：
1. 线性分配：
- 使用简单的指针碰撞分配
- 不需要空闲列表
- 分配速度极快
2. TLAB 支持：
- 支持线程本地分配缓冲区
- 减少线程间竞争
- 提高分配性能
3. 大对象处理：
- 直接在堆中分配
- 不进行特殊处理
- 简单高效
4. 内存屏障：
- 最小化的内存屏障
- 只保证基本的内存一致性
- 不支持并发回收3. 监控和诊断
Epsilon GC 提供基本的监控功能：
监控功能：
1. 内存使用统计：
- 已分配内存大小
- 剩余可用内存
- 分配速率
2. 分配事件记录：
- 大对象分配
- TLAB 分配
- 内存压力警告
3. 性能计数器：
- 分配次数
- 分配时间
- 内存使用峰值
4. 预警机制：
- 内存即将耗尽警告
- 分配失败通知
- 性能异常检测算法实现
Epsilon GC 核心实现
java
// Epsilon GC 的核心实现
public class EpsilonGarbageCollector {
private final EpsilonHeap heap;
private final EpsilonMonitoring monitoring;
private final AtomicLong totalAllocated;
private final AtomicLong allocationCount;
public EpsilonGarbageCollector(long heapSize) {
this.heap = new EpsilonHeap(heapSize);
this.monitoring = new EpsilonMonitoring();
this.totalAllocated = new AtomicLong(0);
this.allocationCount = new AtomicLong(0);
}
// 主要的对象分配方法
public Object allocateObject(int size) {
// 1. 尝试在 TLAB 中分配
Object obj = tryAllocateInTLAB(size);
if (obj != null) {
recordAllocation(size);
return obj;
}
// 2. TLAB 分配失败，尝试在堆中分配
obj = tryAllocateInHeap(size);
if (obj != null) {
recordAllocation(size);
return obj;
}
// 3. 堆内存不足，抛出 OOM
handleOutOfMemory(size);
return null; // 永远不会到达这里
}
private Object tryAllocateInTLAB(int size) {
Thread currentThread = Thread.currentThread();
TLAB tlab = getTLAB(currentThread);
if (tlab.hasSpace(size)) {
return tlab.allocate(size);
}
// 尝试分配新的 TLAB
if (tryAllocateNewTLAB(currentThread, size)) {
tlab = getTLAB(currentThread);
return tlab.allocate(size);
}
return null;
}
private Object tryAllocateInHeap(int size) {
synchronized (heap) {
if (heap.hasSpace(size)) {
return heap.allocate(size);
}
return null;
}
}
private boolean tryAllocateNewTLAB(Thread thread, int minSize) {
int tlabSize = calculateTLABSize(minSize);
synchronized (heap) {
if (heap.hasSpace(tlabSize)) {
TLAB newTLAB = heap.allocateTLAB(tlabSize);
setTLAB(thread, newTLAB);
return true;
}
return false;
}
}
private void handleOutOfMemory(int requestedSize) {
// 记录 OOM 事件
monitoring.recordOOM(requestedSize, heap.getUsedSize(), heap.getTotalSize());
// 打印内存使用统计
printMemoryStatistics();
// 抛出 OutOfMemoryError
throw new OutOfMemoryError(
String.format("Epsilon GC: Unable to allocate %d bytes. " +
"Heap: %d/%d bytes used.",
requestedSize, heap.getUsedSize(), heap.getTotalSize()));
}
private void recordAllocation(int size) {
totalAllocated.addAndGet(size);
allocationCount.incrementAndGet();
monitoring.recordAllocation(size);
// 检查是否需要发出内存压力警告
checkMemoryPressure();
}
private void checkMemoryPressure() {
double usageRatio = (double) heap.getUsedSize() / heap.getTotalSize();
if (usageRatio > 0.95) {
monitoring.recordHighMemoryPressure(usageRatio);
System.err.println("WARNING: Epsilon GC heap is " +
(int)(usageRatio * 100) + "% full");
} else if (usageRatio > 0.90) {
monitoring.recordMediumMemoryPressure(usageRatio);
}
}
// Epsilon GC 不执行任何垃圾回收
public void collect() {
// 什么都不做 - 这就是 Epsilon GC 的核心特点
monitoring.recordGCCall();
// 可以选择打印一些统计信息
if (monitoring.shouldPrintStatistics()) {
printMemoryStatistics();
}
}
private void printMemoryStatistics() {
long used = heap.getUsedSize();
long total = heap.getTotalSize();
long allocated = totalAllocated.get();
long count = allocationCount.get();
System.out.println("Epsilon GC Statistics:");
System.out.println(" Heap: " + used + "/" + total + " bytes (" +
(used * 100 / total) + "% used)");
System.out.println(" Total allocated: " + allocated + " bytes");
System.out.println(" Allocation count: " + count);
System.out.println(" Average allocation size: " +
(count > 0 ? allocated / count : 0) + " bytes");
}
// 获取内存使用统计
public MemoryStatistics getStatistics() {
return new MemoryStatistics(
heap.getUsedSize(),
heap.getTotalSize(),
totalAllocated.get(),
allocationCount.get(),
monitoring.getAllocationRate()
);
}
}堆内存管理实现
java
// Epsilon GC 的堆内存管理
public class EpsilonHeap {
private final long totalSize;
private final long baseAddress;
private volatile long currentPointer;
private final Object allocationLock = new Object();
public EpsilonHeap(long size) {
this.totalSize = size;
this.baseAddress = allocateNativeMemory(size);
this.currentPointer = baseAddress;
}
// 简单的指针碰撞分配
public Object allocate(int size) {
synchronized (allocationLock) {
// 对齐到 8 字节边界
int alignedSize = alignSize(size);
// 检查是否有足够空间
if (currentPointer + alignedSize > baseAddress + totalSize) {
return null; // 内存不足
}
// 分配内存
long objectAddress = currentPointer;
currentPointer += alignedSize;
// 初始化对象头
initializeObjectHeader(objectAddress, size);
return createObjectReference(objectAddress);
}
}
// 分配 TLAB
public TLAB allocateTLAB(int size) {
synchronized (allocationLock) {
int alignedSize = alignSize(size);
if (currentPointer + alignedSize > baseAddress + totalSize) {
return null;
}
long tlabStart = currentPointer;
currentPointer += alignedSize;
return new TLAB(tlabStart, alignedSize);
}
}
public boolean hasSpace(int size) {
int alignedSize = alignSize(size);
return currentPointer + alignedSize <= baseAddress + totalSize;
}
public long getUsedSize() {
return currentPointer - baseAddress;
}
public long getTotalSize() {
return totalSize;
}
public long getFreeSize() {
return totalSize - getUsedSize();
}
private int alignSize(int size) {
// 对齐到 8 字节边界
return (size + 7) & ~7;
}
private void initializeObjectHeader(long address, int size) {
// 初始化对象头信息
// 这里简化处理，实际实现会更复杂
writeInt(address, size);
writeInt(address + 4, 0); // 标记字段
}
private Object createObjectReference(long address) {
// 创建对象引用
// 实际实现会使用 JVM 内部 API
return new ObjectReference(address);
}
// 内存统计和监控
public void printHeapInfo() {
long used = getUsedSize();
long total = getTotalSize();
double usagePercent = (double) used / total * 100;
System.out.println("Epsilon Heap Information:");
System.out.println(" Base Address: 0x" + Long.toHexString(baseAddress));
System.out.println(" Current Pointer: 0x" + Long.toHexString(currentPointer));
System.out.println(" Used: " + formatBytes(used) + " (" +
String.format("%.2f", usagePercent) + "%)");
System.out.println(" Free: " + formatBytes(getFreeSize()));
System.out.println(" Total: " + formatBytes(total));
}
private String formatBytes(long bytes) {
if (bytes < 1024) return bytes + " B";
if (bytes < 1024 * 1024) return (bytes / 1024) + " KB";
if (bytes < 1024 * 1024 * 1024) return (bytes / (1024 * 1024)) + " MB";
return (bytes / (1024 * 1024 * 1024)) + " GB";
}
}TLAB 实现
java
// 线程本地分配缓冲区实现
public class TLAB {
private final long startAddress;
private final int size;
private volatile long currentPointer;
private final long endAddress;
public TLAB(long startAddress, int size) {
this.startAddress = startAddress;
this.size = size;
this.currentPointer = startAddress;
this.endAddress = startAddress + size;
}
// 在 TLAB 中分配对象
public Object allocate(int objectSize) {
int alignedSize = alignSize(objectSize);
// 检查空间
if (currentPointer + alignedSize > endAddress) {
return null;
}
// 分配对象
long objectAddress = currentPointer;
currentPointer += alignedSize;
// 初始化对象
initializeObject(objectAddress, objectSize);
return createObjectReference(objectAddress);
}
public boolean hasSpace(int size) {
int alignedSize = alignSize(size);
return currentPointer + alignedSize <= endAddress;
}
public int getUsedSize() {
return (int) (currentPointer - startAddress);
}
public int getFreeSize() {
return (int) (endAddress - currentPointer);
}
public int getTotalSize() {
return size;
}
public double getUsageRatio() {
return (double) getUsedSize() / size;
}
// 重置 TLAB（用于重用）
public void reset() {
currentPointer = startAddress;
}
// 检查 TLAB 是否几乎满了
public boolean isAlmostFull() {
return getUsageRatio() > 0.95;
}
private int alignSize(int size) {
return (size + 7) & ~7;
}
private void initializeObject(long address, int size) {
// 简化的对象初始化
writeInt(address, size);
}
private Object createObjectReference(long address) {
return new ObjectReference(address);
}
// TLAB 统计信息
public TLABStatistics getStatistics() {
return new TLABStatistics(
getUsedSize(),
getFreeSize(),
getTotalSize(),
getUsageRatio()
);
}
}监控和统计实现
java
// Epsilon GC 监控系统
public class EpsilonMonitoring {
private final AtomicLong totalAllocations = new AtomicLong(0);
private final AtomicLong totalAllocatedBytes = new AtomicLong(0);
private final AtomicLong gcCalls = new AtomicLong(0);
private final AtomicLong oomEvents = new AtomicLong(0);
private volatile long lastStatisticsTime = System.currentTimeMillis();
private volatile long lastAllocatedBytes = 0;
// 记录分配事件
public void recordAllocation(int size) {
totalAllocations.incrementAndGet();
totalAllocatedBytes.addAndGet(size);
// 可选：记录分配历史
if (shouldRecordAllocationHistory()) {
recordAllocationHistory(size, System.currentTimeMillis());
}
}
// 记录 GC 调用（虽然什么都不做）
public void recordGCCall() {
gcCalls.incrementAndGet();
}
// 记录 OOM 事件
public void recordOOM(int requestedSize, long usedMemory, long totalMemory) {
oomEvents.incrementAndGet();
System.err.println("Epsilon GC OutOfMemoryError:");
System.err.println(" Requested: " + requestedSize + " bytes");
System.err.println(" Used: " + usedMemory + " bytes");
System.err.println(" Total: " + totalMemory + " bytes");
System.err.println(" Usage: " + (usedMemory * 100 / totalMemory) + "%");
}
// 记录内存压力
public void recordHighMemoryPressure(double usageRatio) {
System.err.println("HIGH MEMORY PRESSURE: " +
String.format("%.1f", usageRatio * 100) + "% heap used");
}
public void recordMediumMemoryPressure(double usageRatio) {
if (shouldPrintMemoryWarnings()) {
System.out.println("Memory pressure: " +
String.format("%.1f", usageRatio * 100) + "% heap used");
}
}
// 计算分配速率
public double getAllocationRate() {
long currentTime = System.currentTimeMillis();
long currentBytes = totalAllocatedBytes.get();
long timeDiff = currentTime - lastStatisticsTime;
long bytesDiff = currentBytes - lastAllocatedBytes;
if (timeDiff > 0) {
double rate = (double) bytesDiff / timeDiff * 1000; // bytes per second
// 更新统计基准
lastStatisticsTime = currentTime;
lastAllocatedBytes = currentBytes;
return rate;
}
return 0.0;
}
// 获取完整统计信息
public EpsilonStatistics getStatistics() {
return new EpsilonStatistics(
totalAllocations.get(),
totalAllocatedBytes.get(),
gcCalls.get(),
oomEvents.get(),
getAllocationRate()
);
}
// 打印详细统计
public void printDetailedStatistics() {
EpsilonStatistics stats = getStatistics();
System.out.println("=== Epsilon GC Detailed Statistics ===");
System.out.println("Total Allocations: " + stats.getTotalAllocations());
System.out.println("Total Allocated Bytes: " + formatBytes(stats.getTotalAllocatedBytes()));
System.out.println("Average Allocation Size: " +
formatBytes(stats.getAverageAllocationSize()));
System.out.println("Allocation Rate: " + formatBytes((long)stats.getAllocationRate()) + "/sec");
System.out.println("GC Calls: " + stats.getGcCalls());
System.out.println("OOM Events: " + stats.getOomEvents());
System.out.println("========================================");
}
public boolean shouldPrintStatistics() {
// 可以基于时间间隔或分配次数决定
return totalAllocations.get() % 10000 == 0;
}
private boolean shouldRecordAllocationHistory() {
// 可配置是否记录分配历史
return Boolean.getBoolean("epsilon.gc.record.history");
}
private boolean shouldPrintMemoryWarnings() {
return Boolean.getBoolean("epsilon.gc.memory.warnings");
}
private void recordAllocationHistory(int size, long timestamp) {
// 实现分配历史记录
// 可以用于后续分析
}
private String formatBytes(long bytes) {
if (bytes < 1024) return bytes + " B";
if (bytes < 1024 * 1024) return String.format("%.1f KB", bytes / 1024.0);
if (bytes < 1024 * 1024 * 1024) return String.format("%.1f MB", bytes / (1024.0 * 1024));
return String.format("%.1f GB", bytes / (1024.0 * 1024 * 1024));
}
}性能特征
优势
零 GC 开销：
- 没有任何垃圾回收停顿
- 没有并发 GC 线程开销
- 最小的运行时开销
极快的分配速度：
- 简单的指针碰撞分配
- 支持高效的 TLAB
- 无需维护空闲列表
完全可预测：
- 行为完全确定
- 没有 GC 引起的性能抖动
- 便于性能分析
简单实现：
- 代码量最少
- 易于理解和维护
- 调试简单
劣势
内存限制：
- 无法回收内存
- 内存使用只增不减
- 容易出现 OOM
应用场景受限：
- 只适合短生命周期应用
- 不适合长期运行的服务
- 内存需求必须可预测
无垃圾回收：
- 无法处理内存泄漏
- 无法回收循环引用
- 内存利用率低
JVM 参数配置
基础参数
bash
# 启用 Epsilon GC
-XX:+UnlockExperimentalVMOptions # 解锁实验性功能
-XX:+UseEpsilonGC # 启用 Epsilon GC
# 堆内存设置
-Xms4g # 初始堆大小
-Xmx8g # 最大堆大小Epsilon GC 特定参数
bash
# 监控和诊断
-XX:+EpsilonPrintGCApplicationConcurrentTime # 打印应用并发时间
-XX:+EpsilonPrintGCApplicationStoppedTime # 打印应用停顿时间
# 内存管理
-XX:EpsilonTLABSize=1m # TLAB 大小
-XX:+EpsilonUseTLABs # 启用 TLAB
# 统计和日志
-XX:+EpsilonPrintStatistics # 打印统计信息
-XX:EpsilonStatisticsInterval=10 # 统计间隔（秒）调试参数
bash
# 详细日志
-Xlog:gc*:gc.log # GC 日志
-XX:+PrintGCDetails # 详细 GC 信息
# 内存分析
-XX:+PrintGCApplicationConcurrentTime
-XX:+PrintGCApplicationStoppedTime
# 堆转储
-XX:+HeapDumpOnOutOfMemoryError # OOM 时生成堆转储
-XX:HeapDumpPath=/tmp/heap.hprof # 堆转储路径性能测试配置
bash
# 性能基准测试配置
-XX:+UnlockExperimentalVMOptions
-XX:+UseEpsilonGC
-Xms16g -Xmx16g # 固定堆大小
-XX:+AlwaysPreTouch # 预分配内存
-XX:+UseLargePages # 使用大页
-XX:+EpsilonPrintStatistics监控与分析
关键指标
内存使用：
- 堆内存使用率
- 分配速率
- 剩余可用内存
分配统计：
- 总分配次数
- 总分配字节数
- 平均分配大小
性能指标：
- 分配延迟
- 应用吞吐量
- CPU 使用率
监控工具
JVM 内置工具
bash
# 查看内存使用
jstat -gc <pid> 1s
# 查看堆信息
jcmd <pid> GC.run_finalization
# 查看 VM 信息
jcmd <pid> VM.info
# 生成堆转储
jcmd <pid> GC.dump_heap /tmp/heap.hprof自定义监控
java
// 自定义监控示例
public class EpsilonGCMonitor {
private final MemoryMXBean memoryBean;
private final ScheduledExecutorService scheduler;
public EpsilonGCMonitor() {
this.memoryBean = ManagementFactory.getMemoryMXBean();
this.scheduler = Executors.newScheduledThreadPool(1);
}
public void startMonitoring() {
scheduler.scheduleAtFixedRate(this::printMemoryStats, 0, 5, TimeUnit.SECONDS);
}
private void printMemoryStats() {
MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
long used = heapUsage.getUsed();
long max = heapUsage.getMax();
double usagePercent = (double) used / max * 100;
System.out.printf("Heap: %d/%d MB (%.1f%%)%n",
used / 1024 / 1024,
max / 1024 / 1024,
usagePercent);
if (usagePercent > 90) {
System.err.println("WARNING: Heap usage is very high!");
}
}
}典型应用场景
1. 性能基准测试
bash
# 微基准测试配置
-XX:+UnlockExperimentalVMOptions
-XX:+UseEpsilonGC
-Xms8g -Xmx8g
-XX:+AlwaysPreTouch
-XX:+UseLargePages
-XX:+EpsilonPrintStatistics
# 适用于：
# - JMH 基准测试
# - 算法性能测试
# - CPU 密集型计算2. 内存分配研究
bash
# 内存分析配置
-XX:+UnlockExperimentalVMOptions
-XX:+UseEpsilonGC
-Xms4g -Xmx4g
-XX:+EpsilonPrintStatistics
-XX:EpsilonStatisticsInterval=1
-Xlog:gc*:allocation.log
# 适用于：
# - 分配模式分析
# - 内存使用优化
# - 对象生命周期研究3. 短生命周期应用
bash
# 批处理任务配置
-XX:+UnlockExperimentalVMOptions
-XX:+UseEpsilonGC
-Xms2g -Xmx4g
-XX:+HeapDumpOnOutOfMemoryError
# 适用于：
# - 批处理作业
# - 数据转换任务
# - 一次性计算任务4. 微服务应用
bash
# 快速启动服务配置
-XX:+UnlockExperimentalVMOptions
-XX:+UseEpsilonGC
-Xms1g -Xmx2g
-XX:+TieredCompilation
-XX:TieredStopAtLevel=1
# 适用于：
# - 函数即服务（FaaS）
# - 短期运行的微服务
# - 容器化应用与其他 GC 对比
| 特性 | Epsilon GC | Serial GC | Parallel GC | G1 GC | ZGC |
|---|---|---|---|---|---|
| GC 停顿 | 无 | 短 | 中等 | 可控 | 极短 |
| 内存回收 | 无 | 有 | 有 | 有 | 有 |
| 吞吐量 | 最高 | 低 | 高 | 中高 | 中等 |
| 内存开销 | 最低 | 低 | 低 | 中等 | 高 |
| 适用场景 | 测试/短期 | 小应用 | 批处理 | 通用 | 低延迟 |
| 复杂度 | 最简单 | 简单 | 中等 | 复杂 | 最复杂 |
| 成熟度 | 实验性 | 成熟 | 成熟 | 成熟 | 较新 |
最佳实践
1. 选择标准
- 应用类型：短生命周期、批处理、测试
- 内存需求：可预测且有限的内存使用
- 性能要求：需要最高的计算性能
- 运行时间：通常小于几小时
2. 配置建议
- 合理估算内存：确保堆大小足够应用运行
- 启用监控：密切关注内存使用情况
- 设置告警：在内存使用过高时及时通知
- 准备降级：有备用的 GC 策略
3. 注意事项
- 避免内存泄漏：代码必须非常小心内存使用
- 监控内存使用：实时跟踪内存消耗
- 测试充分：确保在预期内存范围内运行
- 准备 OOM 处理：有合适的错误处理机制
4. 开发建议
- 对象重用：尽可能重用对象
- 避免大对象：减少大对象的分配
- 及时释放引用：主动释放不需要的对象引用
- 使用对象池：对于频繁创建的对象使用对象池
故障排查
常见问题
OutOfMemoryError：
原因：堆内存耗尽 解决： - 增加堆大小 - 优化内存使用 - 检查内存泄漏 - 考虑其他 GC内存使用过快：
原因：分配速率过高 解决： - 分析分配模式 - 优化对象创建 - 使用对象池 - 减少临时对象性能不如预期：
原因：内存分配开销或其他因素 解决： - 检查 TLAB 配置 - 优化内存访问模式 - 使用性能分析工具 - 对比其他 GC 的性能
诊断工具
bash
# 内存使用分析
jstat -gc <pid> 250ms
# 堆转储分析
jmap -dump:format=b,file=heap.hprof <pid>
# 性能分析
jprofiler 或 async-profiler
# 自定义监控
-XX:+EpsilonPrintStatistics发展历程与未来
历史发展
- JDK 11：首次引入 Epsilon GC（实验性）
- JDK 12-17：持续改进和优化
- 当前状态：仍为实验性功能
设计目标
- 性能基准：提供无 GC 开销的基准
- 研究工具：用于内存分配研究
- 教育目的：帮助理解 GC 的作用
- 特殊场景：满足特定应用需求
未来发展
- 稳定性提升：可能成为正式功能
- 监控增强：更好的监控和诊断工具
- 集成改进：与其他 JVM 功能更好集成
- 文档完善：更详细的使用指南
总结
Epsilon GC 是一个独特的垃圾回收器，它通过完全不执行垃圾回收来实现零 GC 开销。虽然这种设计限制了它的应用场景，但在特定情况下，如性能基准测试、内存分配研究和短生命周期应用中，Epsilon GC 提供了无与伦比的性能优势。
使用 Epsilon GC 需要开发者对应用的内存使用模式有深入的理解，并且能够确保应用在有限的内存范围内完成工作。对于需要最高计算性能且能够接受内存限制的应用，Epsilon GC 是一个值得考虑的选择。
虽然 Epsilon GC 目前仍是实验性功能，但它为我们提供了一个理解垃圾回收重要性的独特视角，同时也为特定场景下的性能优化提供了新的可能性。