分析 cms gc 日志的核心在于识别 full gc 的触发原因并优化并发阶段,重点查看 concurrent mode failure 和 premature concurrent mark 错误。通过解析 [gc (allocation failure) [cms-concurrent-mark: ...] 等时间戳信息,可以计算并发标记、清理及重分布的实际耗时。若发现频繁 full gc,需结合堆内存使用率调整 -xx:cmsinitiatingoccupancyfraction 参数以避免空间不足。

CMS GC 各阶段耗时如何从日志中统计?
CMS 垃圾回收器采用并发收集策略,其日志详细记录了各个阶段的起止时间和耗时。要统计各阶段耗时,需关注以 [GC 或 [Full GC 开头的行,其中包含 cms 子项的时间戳。主要阶段包括初始标记(Initial Mark)、并发标记(Concurrent Mark)、并发预清理(Concurrent Preclean)、并发 sweep(Sweep)、并发重置(Reset)以及最终的重新分布(Rebuild)。日志中通常以 : [time ms] 的形式给出每个子阶段的耗时总和。

public class CmsLogAnalyzer {
public static void main(String[] args) {
// 模拟一段典型的 CMS GC 日志字符串
String logEntry = "[GC (Allocation Failure) [PSYoungGen: 2048K->0K(2560K)] 2048K->2048K(9984K), 0.0051234 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] \n" +
"[GC (Allocation Failure) -- full gc \n" +
"[PSYoungGen: 2560K->0K(2560K)] [ParOldGen: 7424K->7128K(7424K)] 9984K->7128K(9984K), [Metaspace: 30000K->30000K(1066048K)], 0.0234567 secs] [Times: user=0.02 sys=0.00, real=0.02 secs] \n" +
"[CMS-concurrent-mark-start]\n" +
"[CMS-concurrent-mark: 0.010/0.015 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] \n" +
"[CMS-concurrent-preclean: 0.001/0.002 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] \n" +
"[CMS-concurrent-sweep: 0.005/0.006 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] \n" +
"[CMS-concurrent-reset: 0.001/0.001 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] \n" +
"[Total time: 0.025 secs]";
System.out.println("解析 CMS 各阶段耗时:");
parseCmsStages(logEntry);
}
private static void parseCmsStages(String log) {
// 简单提取 CMS 并发阶段耗时
String[] lines = log.split("\n");
for (String line : lines) {
if (line.contains("CMS-concurrent")) {
// 提取格式如 [CMS-concurrent-mark: 0.010/0.015 secs]
int start = line.indexOf(": ") + 2;
int end = line.indexOf(" secs");
if (start > 0 && end > start) {
String duration = line.substring(start, end).trim();
System.out.println(line.substring(0, start - 2) + " -> " + duration + "s");
}
}
}
}
}
上述代码演示了如何从日志文本中提取 CMS 并发阶段的耗时数据。实际运行中,CMS-concurrent-mark 显示为 0.010/0.015 secs,前者为用户态耗时,后者为真实墙钟时间。开发者应重点关注墙钟时间,因为它反映了应用暂停或并发的实际影响。通过解析这些数值,可以评估 CMS 对应用吞吐量的影响。
立即学习“Java免费学习笔记(深入)”;
如何判断 CMS 是否发生了 Full GC 及其原因?
CMS 回收器旨在减少停顿时间,但在某些情况下仍会触发 Stop-The-World (STW) 的 Full GC。日志中若出现 [Full GC] 标记,即表示发生了完整垃圾回收。常见原因包括 Allocation Failure(分配失败,老年代空间不足)、Concurrent Mode Failure(并发模式失败,即在并发标记期间老年代被填满)以及 Premature Concurrent Mark(过早并发标记,通常由元空间不足或显式调用引起)。分析时需检查 [Full GC (原因) [PSYoungGen: ...] [ParOldGen: ...] 部分,观察老年代回收前后的内存变化。如果回收后内存占用依然很高,说明存在内存泄漏或堆设置过小。

public class CmsFailureDetector {
public static void main(String[] args) {
String failureLog = "[GC (Allocation Failure) [PSYoungGen: 2048K->0K(2560K)] 2048K->2048K(9984K), 0.005 secs] \n" +
"[Full GC (Concurrent Mode Failure) [PSYoungGen: 0K->0K(2560K)] [ParOldGen: 7128K->7128K(7424K)] 7128K->7128K(9984K), [Metaspace: 30000K->30000K(1066048K)], 0.1234567 secs] [Times: user=0.12 sys=0.00, real=0.12 secs]";
detectFailure(failureLog);
}
private static void detectFailure(String log) {
if (log.contains("Concurrent Mode Failure")) {
System.out.println("检测到 CMS 并发模式失败,老年代在并发阶段被填满。");
System.out.println("建议:增加 -XX:MaxHeapSize 或调整 -XX:CMSInitiatingOccupancyFraction");
} else if (log.contains("Premature Concurrent Mark")) {
System.out.println("检测到 CMS 过早并发标记,可能由元空间不足引起。");
System.out.println("建议:检查 Metaspace 使用情况或增加 -XX:MaxMetaspaceSize");
} else if (log.contains("Allocation Failure") && log.contains("Full GC")) {
System.out.println("检测到因分配失败导致的 Full GC,老年代空间不足。");
}
}
}
该程序展示了如何根据日志关键字判断 Full GC 的具体原因。当日志中包含 Concurrent Mode Failure 时,表明 CMS 线程在标记过程中,老年代空间已被新对象填满,导致无法继续并发执行,必须停止应用线程进行串行回收。此时,开发者应优先检查堆大小设置是否合理,或考虑降低对象的分配速率。若遇到 Premature Concurrent Mark,则需关注元空间(Metaspace)的使用情况,因为元空间不足也会触发此类异常。
CMS 日志中 Young Gen 和 Old Gen 的内存变化代表什么?
在 CMS GC 日志中,[PSYoungGen: X->Y(Z)K] 和 [ParOldGen: A->B(C)K] 分别表示年轻代和老年代的内存状态。格式为 使用前->使用后(总容量)。对于 Young Gen,每次 Minor GC 后,存活对象会被晋升到 Old Gen,因此 Young Gen 使用后通常接近 0,而 Old Gen 会增加。对于 Old Gen,CMS 回收后,若回收成功,内存占用会显著下降;若发生 Full GC,则所有区域都会被扫描。通过对比回收前后的数值,可以判断垃圾回收的效率。如果 Old Gen 在使用后几乎没有减少,且总容量接近上限,说明可能存在内存泄漏或堆配置过小。
public class MemoryChangeAnalyzer {
public static void main(String[] args) {
String gcLog = "[GC (Allocation Failure) [PSYoungGen: 2560K->0K(2560K)] [ParOldGen: 7424K->7128K(7424K)] 9984K->7128K(9984K), 0.023 secs]";
analyzeMemoryChanges(gcLog);
}
private static void analyzeMemoryChanges(String log) {
// 提取 Young Gen 变化
int youngStart = log.indexOf("[PSYoungGen: ") + 12;
int youngEnd = log.indexOf("K(", youngStart);
String youngBeforeAfter = log.substring(youngStart, youngEnd);
String[] youngParts = youngBeforeAfter.split("->");
long youngUsedAfter = Long.parseLong(youngParts[1].trim());
// 提取 Old Gen 变化
int oldStart = log.indexOf("[ParOldGen: ") + 13;
int oldEnd = log.indexOf("K(", oldStart);
String oldBeforeAfter = log.substring(oldStart, oldEnd);
String[] oldParts = oldBeforeAfter.split("->");
long oldUsedBefore = Long.parseLong(oldParts[0].trim());
long oldUsedAfter = Long.parseLong(oldParts[1].trim());
System.out.println("Young Gen 回收后剩余: " + youngUsedAfter + "K");
System.out.println("Old Gen 回收前: " + oldUsedBefore + "K, 回收后: " + oldUsedAfter + "K");
System.out.println("Old Gen 释放空间: " + (oldUsedBefore - oldUsedAfter) + "K");
}
}
运行上述代码可清晰看到各代内存的变化量。例如,Young Gen 从 2560K 变为 0K,说明所有年轻代对象要么被回收,要么晋升到了老年代。Old Gen 从 7424K 降至 7128K,释放了 296K 空间。这种量化分析有助于判断 CMS 是否有效清理了垃圾对象。若 Old Gen 释放空间极少,甚至增加,则提示需要进一步优化 JVM 参数或排查代码中的内存泄漏问题。


















