arthas-dashboard

Arthas 监控可视化面板。直观展示 JVM 线程、内存、GC、方法调用等核心指标，并自动检测异常、分级诊断、提供可操作的解决方案。当用户说 "dashboard"、"arthas"、"jvm 监控"、"线程分析"、"内存分析"、"方法耗时"、"CPU 高"、"死锁"、"GC 分析"、"火焰图"、"profiler"、"方法调用链"、"watch 方法"、"trace 方法" 或任何 Arthas 诊断相关需求时使用。

Arthas 监控可视化面板（含异常检测与解决方案）

概述

将 Arthas MCP 工具的结果格式化为直观的表格和图表输出，并自动检测异常、判定严重等级、提供根因分析和可操作的解决方案。

text

                     ┌──────────────────────────────────┐
                     │     Arthas Dashboard              │
                     ├──────────┬───────────────────────┤
                     │ JVM 信息 │ 内存 / GC             │
                     ├──────────┼───────────────────────┤
                     │ 线程分析 │ CPU Profiler          │
                     ├──────────┴───────────────────────┤
                     │ 方法监控 (trace/watch/monitor)   │
                     └──────────────────────────────────┘
                     ↓                                  ↓
                 展示数据      +    异常检测 → 方案

核心原则

每次展示数据后，必须执行异常检测。不要只展示原始数据。

三阶段流程：

1. 数据采集 → 调用 Arthas MCP 工具
2. 可视化展示 → 格式化表格/图表
3. 异常检测与方案 → 逐个指标判定 → 汇总风险 → 给出解决方案

---

异常判定规则引擎

严重等级定义

等级	符号	含义
🔴 CRITICAL	严重	正在发生故障，需立即处理
🟠 HIGH	高	即将故障或性能严重下降
🟡 MEDIUM	中	需关注，趋势恶化中
🟢 LOW	低	微调优化，非紧急
✅ OK	正常	指标健康

分类阈值与检测规则

1. 线程异常

异常	阈值	等级	根因	解决方案
死锁	deadlockCount > 0	🔴 CRITICAL	多个线程循环等待锁	1. 列出死锁链中的锁名称和持有线程 2. 检查代码中 synchronized 嵌套顺序 3. 改为 ReentrantLock.tryLock(timeout) 或统一锁获取顺序 4. 考虑用 java.util.concurrent 无锁数据结构
CPU 单线程异常	cpu% > 80% 持续	🔴 CRITICAL	死循环或密集计算	1. trace该线程方法 trace className methodName 2. 检查是否有无界循环 while(true) 3. 添加 Thread.sleep 或改用异步/批处理
CPU 单线程偏高	cpu% > 50%	🟠 HIGH	方法效率低	1. trace 热点方法调用链 2. 检查算法复杂度 3. 考虑缓存/异步化
BLOCKED 线程	count > 0	🟠 HIGH	锁竞争	1. thread -b 找到阻塞源 2. 缩小 synchronized 代码块范围 3. 使用 ConcurrentHashMap/ReadWriteLock 替代
WAITING 过多	> 50% 总线程	🟡 MEDIUM	线程池耗尽/连接池满	1. 检查线程池 corePoolSize/maxPoolSize 2. 排查是否有未被释放的资源 3. 检查连接池（数据库/Redis/HTTP）大小和超时配置
线程总数过高	> 500	🟡 MEDIUM	线程池泄漏	1. 排查所有 Executors.newCachedThreadPool 2. 改用固定大小线程池 3. 检查 ThreadLocal 是否有 remove
线程持续增长	5分钟内增长 >100	🟠 HIGH	线程泄漏	1. jmap dump 线程栈分析 2. 检查 new Thread() 是否有对应 stop 3. 排查动态代理/定时任务

2. 内存异常

异常	阈值	等级	根因	解决方案
堆内存耗尽	heapUsage > 90%	🔴 CRITICAL	内存泄漏或堆设置过小	1. heapdump 导出 dump 2. 用 MAT/JProfiler 分析大对象 3. 如对象正常增多则 -Xmx 扩容 4. 如有泄漏：检查静态集合、ThreadLocal、缓存未过期、监听器未注销
堆内存高	heapUsage > 80%	🟠 HIGH	缓存过大/泄漏	1. 检查本地缓存 CacheManager 大小 2. 排查大 List/Map 是否合理 3. 考虑 LRU/弱引用
Old 区高	oldUsage > 80%	🟠 HIGH	对象过早晋升或泄漏	1. 检查 -XX:PretenureSizeThreshold 大对象直接进 Old 2. 检查 Survivor 区是否过小 3. 排查是否有长期持有引用的对象
Metaspace 满	usage > 90%	🔴 CRITICAL	类加载过多	会导致 OOM: Metaspace，参考下方 Metaspace 专项
Metaspace 高	usage > 80%	🟠 HIGH	类过多	1. -XX:+TraceClassLoading 查看加载的类 2. 排查动态代理 CGLIB/JDK Proxy 是否大量生成 3. 检查 Groovy/热部署是否不停加载类 4. 调大 -XX:MaxMetaspaceSize=256M 或关闭热部署
CodeCache 满	usage > 80%	🟡 MEDIUM	JIT 编译代码过多	1. -XX:ReservedCodeCacheSize=256M 扩容 2. 检查是否大量使用反射生成代码
Direct Buffer 高	usage > 80%	🟡 MEDIUM	NIO 直接内存未释放	1. 检查 Netty 是否 release() 2. -XX:MaxDirectMemorySize 调大 3. 排查 ByteBuffer.allocateDirect 是否有泄漏
内存泄漏特征	Full GC 后 heap 不降 + Old 持续上升	🔴 CRITICAL	内存泄漏	1. heapdump 生成 dump 2. MAT: Histogram → 找可疑对象 → GC Roots 路径 3. 检查静态 HashMap/ArrayList 有无无界增长 4. 检查 ThreadLocal.remove() 是否遗漏

3. GC 异常

异常	阈值	等级	根因	解决方案
Full GC 频繁	> 5次/小时	🟠 HIGH	内存不足或碎片	1. 增大 -Xmx 2. 检查大对象分配 3. 考虑换 G1GC -XX:+UseG1GC
Full GC 超频繁	> 1次/分钟	🔴 CRITICAL	堆太小/严重泄漏	1. 立即 heapdump 分析 2. 紧急 -Xmx 翻倍 3. 排查大对象/内存泄漏
Young GC 频繁	> 10次/分钟	🟡 MEDIUM	对象分配速率过高	1. 增大 Young 区 -Xmn 2. trace 高频方法检查是否大量 new 临时对象 3. 考虑对象池/复用
GC 平均暂停长	YoungGC Avg > 50ms 或 FullGC Avg > 500ms	🟠 HIGH	GC 算法不当或堆太大	1. 换 G1GC 并设 -XX:MaxGCPauseMillis=200 2. 减小堆大小减少 STW 时间
Full GC 后内存不降	GC 后 oldUsed 几乎不变	🔴 CRITICAL	严重内存泄漏	1. heapdump 分析 2. 排查静态引用链 3. 检查 JNDI/JMX/ClassLoader 泄漏

4. 系统异常

异常	阈值	等级	根因	解决方案
CPU 负载高	Load > CPU核数	🟠 HIGH	CPU 瓶颈	1. profiler 采样找热点 2. 优化算法 3. 加机器/加核
文件描述符耗尽	fdUsage > 90%	🔴 CRITICAL	fd 泄漏	1. lsof -p PID | wc -l 查看 2. 检查 Socket/FileInputStream 是否 finally close 3. 调整 ulimit -n
文件描述符高	fdUsage > 70%	🟡 MEDIUM	连接过多	1. 检查连接池 2. 确认连接是否及时关闭
编译耗时高	totalCompileTime / uptime > 30%	🟡 MEDIUM	JIT 过度编译	1. 检查是否 -Xcomp 强制编译 2. 用分层编译 -XX:+TieredCompilation

5. 方法级异常

异常	阈值	等级	根因	解决方案
单方法 CPU 热点	profiler 占比 > 20%	🔴 CRITICAL	该方法严重拖慢系统	1. trace 调用链找到子方法瓶颈 2. 优化算法/加缓存/异步化 3. 考虑批量处理
方法 RT 过高	avgRT > 500ms	🟡 MEDIUM	慢查询/远程调用慢	1. trace 分析各子方法耗时 2. 检查 DB 索引/SQL 优化 3. 检查外部 API 超时配置
方法 RT 严重	avgRT > 2000ms	🟠 HIGH	严重慢调用	同上，优先处理
成功率低	successRate < 95%	🔴 CRITICAL	异常比例高	1. watch 捕获异常详情 2. 排查下游依赖健康 3. 添加熔断降级
QPS 突增	QPS > 正常值 3x	🟡 MEDIUM	流量突增	1. 确认是否正常业务增长 2. 限流 Sentinal/Guava RateLimiter 3. 扩容

6. 类加载异常

异常	阈值	等级	根因	解决方案
类数量过多	loaded > 30000	🟡 MEDIUM	类膨胀	1. 检查框架是否生成大量代理类 2. 排查 Groovy/JS 脚本引擎类 3. 检查 Lambda 过多
类持续增长	5分钟内 >500	🟠 HIGH	类加载泄漏	1. classloader 查看各加载器数量 2. 排查热部署/动态代理是否正常卸载
已卸载类残留	unloaded 异常增长	🟡 MEDIUM	Metaspace 未回收	1. 检查 -XX:+CMSClassUnloadingEnabled 2. 排查是否有 ClassLoader 引用未释放

---

决策树

text

用户输入关键词                 → 执行动作
─────────────────────────────────────────────
dashboard / jvm / 综合 / 大盘    → 场景A: 综合仪表盘
线程 / thread / CPU高 / 死锁     → 场景B: 线程分析
内存 / memory / GC / 堆          → 场景C: 内存与GC分析
profiler / 火焰图 / CPU热点      → 场景D: CPU Profiler
trace / watch / monitor / 方法   → 场景E: 方法级监控
系统属性 / sysprop / JVM参数     → 场景F: 系统参数
类加载 / classloader             → 场景G: 类加载分析
默认（无关键词）                → 场景A: 综合仪表盘

---

场景A: 综合仪表盘

目标: 一屏展示 JVM 健康状态全貌 + 异常检测总结。

工具调用: 并行调用 mcp__arthas__jvm、mcp__arthas__memory、mcp__arthas__thread（topN=10）。

A1. 数据展示

text

╔══════════════════════════════════════════════════════════════════╗
║                    🔍 JVM 综合仪表盘                            ║
╠══════════════════════════════════════════════════════════════════╣
║ 基本信息                                                       ║
║   PID: {pid}  |  启动时间: {startTime}  |  运行时长: {uptime}   ║
║   JDK: {javaVersion}  |  VM: {vmName} ({vmVendor})             ║
║   OS: {osName} {osArch}  |  CPU核数: {processors}              ║
║   JVM参数: -Xms{ms} -Xmx{mx}                                   ║
╠══════════════════════════════════════════════════════════════════╣
║ 内存概览                                                       ║
║   HEAP:      [bar] {used}MB / {max}MB ({pct}%)                 ║
║   NON-HEAP:  [bar] {used}MB / {max}MB ({pct}%)                 ║
║                                                               ║
║   分区:                                                        ║
║   Eden:      [bar] {used}MB / {max}MB ({pct}%)                 ║
║   Survivor:  [bar] {used}MB / {max}MB ({pct}%)                 ║
║   Old:       [bar] {used}MB / {max}MB ({pct}%)                 ║
║   Metaspace: [bar] {used}MB / {max}MB ({pct}%)                 ║
║   CodeCache: [bar] {used}MB / {max}MB ({pct}%)                 ║
╠══════════════════════════════════════════════════════════════════╣
║ GC 统计                                                        ║
║   收集器: {gcNames}                                            ║
║   Young GC: {count}次  |  耗时{time}ms  |  均{avg}ms          ║
║   Full GC:  {count}次  |  耗时{time}ms  |  均{avg}ms          ║
╠══════════════════════════════════════════════════════════════════╣
║ 线程概览                                                       ║
║   活跃:{live} | 守护:{daemon} | 峰值:{peak} | 启动累计:{started}║
║                                                               ║
║   🟢 RUNNABLE:     {n}                                        ║
║   🟡 TIMED_WAITING:{n}                                        ║
║   🟠 WAITING:      {n}                                        ║
║   🔴 BLOCKED:      {n}                                        ║
║                                                               ║
║   TOP CPU 线程:                                               ║
║   ┌──────┬──────────┬────────────────────────────────────┐    ║
║   │ CPU% │  状态    │ 线程名 / 方法                      │    ║
║   ├──────┼──────────┼────────────────────────────────────┤    ║
║   │ x.xx │ XXXXXXXX │ xxxxxxx                            │    ║
║   └──────┴──────────┴────────────────────────────────────┘    ║
╠══════════════════════════════════════════════════════════════════╣
║ 类加载  |  文件描述符                                          ║
║   已加载:{loaded} | 已卸载:{unloaded} | FD:{fdUsed}/{fdMax}    ║
╚══════════════════════════════════════════════════════════════════╝

A2. 异常检测与健康评分

数据展示之后，立即逐项检测并输出异常报告：

text

╔══════════════════════════════════════════════════════════════════╗
║            🏥 异常检测报告                                      ║
╠══════════════════════════════════════════════════════════════════╣
║ 健康评分: {score}/100  [████████░░]                            ║
╠══════════════════════════════════════════════════════════════════╣
║ 发现 {N} 个异常:                                               ║
║                                                               ║
║ 🔴 [{level}] {title}                                          ║
║   当前值: {current}  阈值: {threshold}                         ║
║   根因: {rootCause}                                           ║
║   方案:                                                       ║
║     1. {step1}                                                ║
║     2. {step2}                                                ║
║   [如需要，提示执行的具体 Arthas 命令]                         ║
║                                                               ║
║ 🟠 [{level}] {title}                                          ║
║   ...                                                          ║
╠══════════════════════════════════════════════════════════════════╣
║ 正常指标: threadCount, deadlock, edenUsage, ...                ║
╚══════════════════════════════════════════════════════════════════╝

健康评分计算规则:

text

初始 100 分
每个 🔴 CRITICAL: -20 分
每个 🟠 HIGH:      -10 分
每个 🟡 MEDIUM:     -5 分
最低 0 分

A3. 数据映射规则

从 mcp__arthas__jvm 结果中提取:

• RUNTIME[].value 按 name 匹配: MACHINE-NAME, JVM-START-TIME, VM-NAME, VM-VENDOR, VM-VERSION, INPUT-ARGUMENTS
• OPERATING-SYSTEM[].value 按 name 匹配: OS, ARCH, PROCESSORS-COUNT, LOAD-AVERAGE
• MEMORY[0].value → HEAP-MEMORY-USAGE (used/committed/max)
• MEMORY[1].value → NO-HEAP-MEMORY-USAGE (used/committed/max)
• GARBAGE-COLLECTORS[].value → collectionCount/collectionTime
• CLASS-LOADING[].value → LOADED-CLASS-COUNT/TOTAL-LOADED-CLASS-COUNT/UNLOADED-CLASS-COUNT
• THREAD[].value → COUNT/DAEMON-COUNT/PEAK-COUNT/STARTED-COUNT/DEADLOCK-COUNT
• FILE-DESCRIPTOR[].value → MAX/OPEN

从 mcp__arthas__memory 结果中提取:

• heap[] 数组: name/total/used/max → 各内存池详情
• nonheap[] 数组: name/total/used/max → 非堆详情

从 mcp__arthas__thread (topN=10) 结果中提取:

• busyThreads[] → cpu/state/name/id/stackTrace[0]

Progress bar:

text

totalWidth = 10
filled = max(0, min(10, round(pct / 100 * totalWidth)))
bar = "█" * filled + "░" * (totalWidth - filled)
pct < 60 → normal, 60-80 → warning, >80 → danger

---

场景B: 线程分析

工具调用: mcp__arthas__thread（topN=10, all=true, blocking=true）

B1. 数据展示

text

╔══════════════════════════════════════════════════════════════════╗
║                      🧵 线程分析报告                            ║
╠══════════════════════════════════════════════════════════════════╣
║ 死锁检测                                                       ║
║   {结果，如有死锁展示完整死锁链}                                ║
╠══════════════════════════════════════════════════════════════════╣
║ 线程状态分布                                                   ║
║   🟢 RUNNABLE:         {n}  [{bar}]                            ║
║   🟡 TIMED_WAITING:    {n}  [{bar}]                            ║
║   🟠 WAITING:          {n}  [{bar}]                            ║
║   🔴 BLOCKED:          {n}  [{bar}]                            ║
║   ⚫ NEW/TERMINATED:   {n}  [{bar}]                            ║
╠══════════════════════════════════════════════════════════════════╣
║ TOP {N} CPU 占用线程                                           ║
║ ┌──────┬───────┬──────────┬────────────────────────────────┐   ║
║ │ CPU% │  ID   │   状态   │ 线程名 / 方法摘要              │   ║
║ ├──────┼───────┼──────────┼────────────────────────────────┤   ║
║ │ x.xx │ xxxx  │ XXXXXXXX │ xxxxx                          │   ║
║ └──────┴───────┴──────────┴────────────────────────────────┘   ║
╚══════════════════════════════════════════════════════════════════╝

B2. 异常检测

根据线程异常表逐项检测：

• deadlockCount > 0 → 🔴 死锁
• 任一 busyThread.cpu > 80% → 🔴 单线程 CPU 异常
• 任一 busyThread.cpu > 50% → 🟠 单线程 CPU 偏高
• BLOCKED 数量 > 0 → 🟠 锁竞争
• WAITING / total > 50% → 🟡 线程池可能耗尽

输出异常报告，每项包含：当前值、阈值、根因、步骤化解决方案。

---

场景C: 内存与GC分析

工具调用: mcp__arthas__memory、mcp__arthas__jvm

C1. 数据展示

text

╔══════════════════════════════════════════════════════════════════╗
║                    📦 内存与 GC 分析                            ║
╠══════════════════════════════════════════════════════════════════╣
║ 堆内存 (Heap)                                                  ║
║   已用: {used} / {committed} (最大: {max})                     ║
║   [bar] {pct}%                                                ║
║                                                               ║
║   ┌─────────────┬──────────────┬──────────┬──────────┬──────┐ ║
║   │   区域       │   已用       │   上限    │   占比   │ 状态 │ ║
║   ├─────────────┼──────────────┼──────────┼──────────┼──────┤ ║
║   │ Eden        │   xxMB       │  xxMB    │  xx.x%   │  OK  │ ║
║   │ Survivor    │   xxMB       │  xxMB    │  xx.x%   │  OK  │ ║
║   │ Old         │   xxMB       │  xxMB    │  xx.x%   │  OK  │ ║
║   └─────────────┴──────────────┴──────────┴──────────┴──────┘ ║
╠══════════════════════════════════════════════════════════════════╣
║ 非堆内存 (Non-Heap)                                            ║
║   已用: {used} / {committed}                                   ║
║   [bar] {pct}%                                                ║
║                                                               ║
║   ┌─────────────┬──────────────┬──────────┬──────────┬──────┐ ║
║   │ Metaspace   │   xxMB       │  xxMB    │  xx.x%   │  OK  │ ║
║   │ Compressed  │   xxMB       │  xxMB    │  xx.x%   │  OK  │ ║
║   │ Code Cache  │   xxMB       │  xxMB    │  xx.x%   │  OK  │ ║
║   └─────────────┴──────────────┴──────────┴──────────┴──────┘ ║
╠══════════════════════════════════════════════════════════════════╣
║ GC 统计                                                        ║
║ ┌────────────────┬──────────┬──────────┬──────────────────┐    ║
║ │ 收集器          │ 次数     │ 总耗时   │ 平均耗时         │    ║
║ ├────────────────┼──────────┼──────────┼──────────────────┤    ║
║ │ {youngGC}      │  {n}     │  {t}ms   │  {avg}ms         │    ║
║ │ {fullGC}       │  {n}     │  {t}ms   │  {avg}ms         │    ║
║ └────────────────┴──────────┴──────────┴──────────────────┘    ║
║ GC 频率: Young {n}/min  |  Full {n}/hour                       ║
╚══════════════════════════════════════════════════════════════════╝

C2. 异常检测

根据内存异常表和 GC 异常表逐项检测（注意计算 GC 频率需要结合 uptime）：

• heapUsage > 90% → 🔴 堆内存耗尽
• heapUsage > 80% → 🟠 堆内存高
• oldUsage > 80% → 🟠 Old 区高
• metaspaceUsage > 90% → 🔴 Metaspace 满
• metaspaceUsage > 80% → 🟠 Metaspace 高
• fullGC freq > 1/min → 🔴 Full GC 超频繁
• fullGC freq > 5/hour → 🟠 Full GC 频繁
• youngGC freq > 10/min → 🟡 Young GC 频繁
• youngGC avg > 50ms → 🟠 Young GC 暂停长
• fullGC avg > 500ms → 🟠 Full GC 暂停长

GC 频率计算:

text

uptime_min = 当前时间 - JVM-START-TIME (分钟)
youngGC_freq = youngGC_count / uptime_min  (次/分钟)
fullGC_freq = fullGC_count / uptime_min    (次/分钟)

输出异常报告，每项包含完全可操作的步骤化解决方案。

---

场景D: CPU Profiler

工具调用: mcp__arthas__profiler + mcp__arthas__stop

步骤:

1. 启动 profiler: 调用 mcp__arthas__profiler 启动 CPU 采样
2. 提示用户: "正在采样，请等待 30-60 秒..."
3. 获取结果: 再次调用 mcp__arthas__profiler
4. 停止 profiler: 调用 mcp__arthas__stop 停止

D1. 数据展示

text

╔══════════════════════════════════════════════════════════════════╗
║                    🔥 CPU 热点分析                              ║
╠══════════════════════════════════════════════════════════════════╣
║ 采样时长: {duration}s  |  采样次数: {samples}                  ║
╠══════════════════════════════════════════════════════════════════╣
║ TOP 热点方法                                                    ║
║ ┌──────┬──────────────────────────────────┬────────────────────┐║
║ │ 占比  │ 方法                             │ 文件位置          │║
║ ├──────┼──────────────────────────────────┼────────────────────┤║
║ │ 15%  │ com.xxx.Service.processData       │ Service.java:42   │║
║ │ 12%  │ java.util.HashMap.get             │ (JDK)             │║
║ │  8%  │ org.xxx.Mapper.findById           │ Mapper.java:15    │║
║ └──────┴──────────────────────────────────┴────────────────────┘║
╚══════════════════════════════════════════════════════════════════╝

D2. 异常检测

• 任一方法占比 > 30% → 🔴 极端热点，建议 trace + 优化
• 任一方法占比 > 20% → 🟠 显著热点，建议 trace 分析
• top3 合计 > 50% → 🟡 CPU 集中在少数方法
• 大量 JDK 方法占比高（如 HashMap.get/I/O）→ 框架/中间件使能有问题

每项输出根因和解决方案。

---

场景E: 方法级监控

E1 - trace（方法调用链与耗时）

工具调用: mcp__arthas__trace

text

╔══════════════════════════════════════════════════════════════════╗
║               🔎 Trace: {className}#{methodName}                ║
╠══════════════════════════════════════════════════════════════════╣
║ 调用次数: {n}  |  总耗时: {total}ms  |  平均: {avg}ms          ║
╠══════════════════════════════════════════════════════════════════╣
║  调用链 (耗时分布):                                            ║
║                                                               ║
║  ┌── {methodName}  [总耗时: 120ms, 100%]                      ║
║  │                                             			     ║
║  ├── checkAuth()         [80ms, 67%] ← 🔴 热点               ║
║  │   ├── queryUser()     [50ms, 42%]                          ║
║  │   └── verifyToken()   [30ms, 25%]                          ║
║  │                                             			     ║
║  ├── loadData()          [30ms, 25%]                          ║
║  │   └── dbQuery()       [30ms, 25%]                          ║
║  │                                             			     ║
║  └── buildResponse()     [10ms, 8%]                           ║
╠══════════════════════════════════════════════════════════════════╣
║ 异常检测:                                                      ║
║ [如 avg > 500ms] 🟡 方法平均耗时偏高                          ║
║ [如 avg > 2000ms] 🟠 方法平均耗时严重                         ║
║ [如某子方法占比 > 50%] → 标注该子方法为瓶颈                   ║
╠══════════════════════════════════════════════════════════════════╣
║ 优化建议:                                                      ║
║   [针对热点子方法给出具体优化方案]                              ║
╚══════════════════════════════════════════════════════════════════╝

E2 - watch（方法入参/返回值/异常）

工具调用: mcp__arthas__watch

text

╔══════════════════════════════════════════════════════════════════╗
║            👁️  Watch: {className}#{methodName}                  ║
╠══════════════════════════════════════════════════════════════════╣
║ 调用 #{n}  |  耗时: {cost}ms                                  ║
║─────────────────────────────────────────────────────────────── ║
║ 📥 入参:                                                       ║
║   param1: {value1}                                             ║
║   param2: {value2}                                             ║
║─────────────────────────────────────────────────────────────── ║
║ 📤 返回值:                                                      ║
║   {returnValue}                                                ║
║─────────────────────────────────────────────────────────────── ║
║ ❌ 异常 (如有):                                                ║
║   {exception}                                                  ║
╠══════════════════════════════════════════════════════════════════╣
║ 异常检测:                                                      ║
║ [如有异常] 展示异常类型 + 根因 + 修复建议                      ║
║ [如耗时 > 500ms] 标注慢调用                                    ║
╚══════════════════════════════════════════════════════════════════╝

E3 - monitor（方法调用统计）

工具调用: mcp__arthas__monitor

text

╔══════════════════════════════════════════════════════════════════╗
║          📊 Monitor: {className}#{methodName}                   ║
╠══════════════════════════════════════════════════════════════════╣
║ 时间窗口: {timestamp}                                          ║
║                                                               ║
║   QPS:      {qps}/s      (总调用: {total})                    ║
║   平均RT:    {avg}ms                                         ║
║   最小RT:    {min}ms  |  最大RT: {max}ms                     ║
║   成功率:    {successRate}%                                   ║
║                                                               ║
║   RT分布:                                                     ║
║   0-10ms:    [bar] {n}个 ({pct}%)                             ║
║   10-50ms:   [bar] {n}个 ({pct}%)                             ║
║   50-100ms:  [bar] {n}个 ({pct}%)                             ║
║   100-500ms: [bar] {n}个 ({pct}%)                             ║
║   500ms+:    [bar] {n}个 ({pct}%)                             ║
╠══════════════════════════════════════════════════════════════════╣
║ 异常检测:                                                      ║
║ [successRate < 95%] 🔴 成功率低 → 建议 watch 捕获异常         ║
║ [avgRT > 500ms] 🟡 平均RT偏高                                ║
║ [avgRT > 2000ms] 🟠 平均RT严重                               ║
║ [500ms+ 占比 > 10%] 🟡 存在慢调用长尾                         ║
╠══════════════════════════════════════════════════════════════════╣
║ 优化建议:                                                      ║
║   [针对性优化方案]                                             ║
╚══════════════════════════════════════════════════════════════════╝

---

场景F: 系统参数

工具调用: 并行调用 mcp__arthas__sysprop、mcp__arthas__sysenv、mcp__arthas__vmoption

text

╔══════════════════════════════════════════════════════════════════╗
║                    ⚙️  系统参数                                ║
╠══════════════════════════════════════════════════════════════════╣
║ JVM 参数 (关键)                                                ║
║   -Xms/Xmx:   {ms} / {mx}                                     ║
║   -Xss:       {value}                                         ║
║   GC:         {gc相关}                                        ║
║   Metaspace:  {metaspace相关}                                 ║
║   HeapDump:   {dump相关}                                      ║
╠══════════════════════════════════════════════════════════════════╣
║ 环境变量 (业务相关)                                            ║
║   SPRING_PROFILES_ACTIVE: {value}                              ║
║   JAVA_HOME:             {value}                               ║
║   SERVER_PORT:           {value}                               ║
╠══════════════════════════════════════════════════════════════════╣
║ 异常检测:                                                      ║
║ [-Xms != -Xmx 且gc频繁] 🟡 堆扩容引起GC，建议设为相同值       ║
║ [无 -XX:+HeapDumpOnOutOfMemoryError] 🟡 建议添加OOM自动dump   ║
║ [无 GC 日志] 🟡 建议开启GC日志 -Xloggc                        ║
║ [-Xmx < 1G 且heapUsage > 70%] 🟠 堆可能偏小                  ║
╚══════════════════════════════════════════════════════════════════╝

---

场景G: 类加载分析

工具调用: mcp__arthas__classloader

text

╔══════════════════════════════════════════════════════════════════╗
║                    📚 类加载器分析                              ║
╠══════════════════════════════════════════════════════════════════╣
║ ┌──────────────────────┬────────────────┬──────────┐           ║
║ │ 类加载器             │ 已加载类数      │ 父加载器 │           ║
║ ├──────────────────────┼────────────────┼──────────┤           ║
║ │ BootstrapClassLoader │  3,500         │  null    │           ║
║ │ AppClassLoader       │  8,200         │  Platform│           ║
║ │ TomcatWebappClassLdr │  2,100         │  App     │           ║
║ └──────────────────────┴────────────────┴──────────┘           ║
║ 总计已加载类: {total}                                          ║
╠══════════════════════════════════════════════════════════════════╣
║ 异常检测:                                                      ║
║ [loaded > 30000] 🟡 类数量过多 → 检查代理/脚本引擎            ║
║ [某加载器 > 10000] 🟡 该加载器类过多 → 检查该模块              ║
╚══════════════════════════════════════════════════════════════════╝

---

格式化工具规则

字节单位转换

text

< 1024             → {n} B
< 1024*1024        → {n/1024:.1f} KB
< 1024*1024*1024   → {n/1024/1024:.1f} MB
>= 1024*1024*1024  → {n/1024/1024/1024:.2f} GB

时间格式化

text

< 1000ms           → {n}ms
< 60000ms          → {n/1000:.1f}s
>= 60000ms         → {n/60000}m {n%60000/1000}s

Progress Bar

text

totalWidth = 10
filled = max(0, min(10, round(pct / 100 * totalWidth)))
bar = "█" * filled + "░" * (totalWidth - filled)

表格对齐

• 数字右对齐，最小宽度6
• 字符串左对齐，最小宽度12
• 方法名截断>50字符加 "..."
• 状态列：OK/正常 绿色，警告 黄色，异常 红色

---

指令边界

• 安全: 此 skill 仅调用只读 Arthas 诊断命令。绝不调用 redefine、retransform、mc、vmtool 等修改类行为的命令，除非用户明确要求。
• 性能: profiler 和 trace 对性能有影响，使用后提示"诊断完成，建议及时停止 profiler/trace 以减少开销"。
• 目标获取: 如果用户未指定要监控的类名/方法名，先调用 mcp__arthas__sc 或 mcp__arthas__sm 搜索候选。
• 错误处理: 如果 Arthas MCP 调用失败，提示"Arthas 连接异常，请检查: (1) Arthas Agent 是否已 attach 到目标 JVM, (2) MCP Server 是否正常运行"。

---

调用模式

并行调用 (场景A 仪表盘示例)

text

在单个消息中同时调用:
  mcp__arthas__jvm()
  mcp__arthas__memory()
  mcp__arthas__thread(topN=10)

→ 等待全部返回 → 格式化展示 → 异常检测

顺序调用 (场景D profiler 示例)

text

第1步: mcp__arthas__profiler 启动采样
第2步: 等待确认(30秒后)再次调用获取结果
第3步: mcp__arthas__stop 停止

---

快速参考

用户说	执行场景	关键工具
"dashboard" / "看大盘"	场景A	jvm + memory + thread
"线程很忙" / "CPU高"	场景B	thread -n 20
"有没有死锁"	场景B	thread -b
"内存快满了" / "查看GC"	场景C	memory + jvm
"哪个方法最慢"	场景E	trace / monitor
"看方法的入参返回值"	场景E	watch
"JVM参数是什么"	场景F	vmoption + sysprop
"加载了多少类"	场景G	classloader
"CPU热点" / "火焰图"	场景D	profiler