Java实现JVM监控案例

wen java案例 2026-08-04 161

本文目录导读：

Java实现JVM监控案例

核心监控类
监控数据格式化输出
监控服务类
主程序入口
运行测试类
运行说明
功能特点

我来提供一个完整的Java JVM监控实现案例，包含内存、线程、GC等多个维度的监控。

核心监控类

JVMMonitor.java

import java.lang.management.*;
import java.util.*;
import javax.management.*;
import com.sun.management.OperatingSystemMXBean;
public class JVMMonitor {
    // 内存监控
    public static Map<String, Object> getMemoryInfo() {
        Map<String, Object> memoryInfo = new HashMap<>();
        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
        // 堆内存
        MemoryUsage heapMemory = memoryMXBean.getHeapMemoryUsage();
        memoryInfo.put("heapInit", heapMemory.getInit());
        memoryInfo.put("heapMax", heapMemory.getMax());
        memoryInfo.put("heapUsed", heapMemory.getUsed());
        memoryInfo.put("heapCommitted", heapMemory.getCommitted());
        // 非堆内存
        MemoryUsage nonHeapMemory = memoryMXBean.getNonHeapMemoryUsage();
        memoryInfo.put("nonHeapInit", nonHeapMemory.getInit());
        memoryInfo.put("nonHeapMax", nonHeapMemory.getMax());
        memoryInfo.put("nonHeapUsed", nonHeapMemory.getUsed());
        memoryInfo.put("nonHeapCommitted", nonHeapMemory.getCommitted());
        // 内存池详情
        List<Map<String, Object>> memoryPools = new ArrayList<>();
        for (MemoryPoolMXBean pool : ManagementFactory.getMemoryPoolMXBeans()) {
            Map<String, Object> poolInfo = new HashMap<>();
            poolInfo.put("name", pool.getName());
            poolInfo.put("type", pool.getType().toString());
            poolInfo.put("usage", pool.getUsage());
            poolInfo.put("peakUsage", pool.getPeakUsage());
            memoryPools.add(poolInfo);
        }
        memoryInfo.put("memoryPools", memoryPools);
        return memoryInfo;
    }
    // 线程监控
    public static Map<String, Object> getThreadInfo() {
        Map<String, Object> threadInfo = new HashMap<>();
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        threadInfo.put("threadCount", threadMXBean.getThreadCount());
        threadInfo.put("peakThreadCount", threadMXBean.getPeakThreadCount());
        threadInfo.put("totalStartedThreadCount", threadMXBean.getTotalStartedThreadCount());
        threadInfo.put("daemonThreadCount", threadMXBean.getDaemonThreadCount());
        // 死锁检测
        long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();
        threadInfo.put("deadlockedThreads", deadlockedThreads != null ? deadlockedThreads.length : 0);
        // 线程详情
        List<Map<String, Object>> threads = new ArrayList<>();
        for (ThreadInfo info : threadMXBean.dumpAllThreads(true, true)) {
            Map<String, Object> thread = new HashMap<>();
            thread.put("threadId", info.getThreadId());
            thread.put("threadName", info.getThreadName());
            thread.put("threadState", info.getThreadState().toString());
            thread.put("blockedCount", info.getBlockedCount());
            thread.put("blockedTime", info.getBlockedTime());
            thread.put("waitedCount", info.getWaitedCount());
            thread.put("waitedTime", info.getWaitedTime());
            // 堆栈信息
            StackTraceElement[] stackTrace = info.getStackTrace();
            thread.put("stackTraceLength", stackTrace.length);
            threads.add(thread);
        }
        threadInfo.put("threads", threads);
        return threadInfo;
    }
    // GC监控
    public static Map<String, Object> getGCInfo() {
        Map<String, Object> gcInfo = new HashMap<>();
        List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans();
        long totalGcCount = 0;
        long totalGcTime = 0;
        List<Map<String, Object>> gcDetails = new ArrayList<>();
        for (GarbageCollectorMXBean gc : gcBeans) {
            Map<String, Object> gcDetail = new HashMap<>();
            long count = gc.getCollectionCount();
            long time = gc.getCollectionTime();
            gcDetail.put("name", gc.getName());
            gcDetail.put("collectionCount", count);
            gcDetail.put("collectionTime", time);
            // GC内存池
            String[] poolNames = gc.getMemoryPoolNames();
            gcDetail.put("memoryPools", Arrays.toString(poolNames));
            gcDetails.add(gcDetail);
            totalGcCount += count;
            totalGcTime += time;
        }
        gcInfo.put("totalGcCount", totalGcCount);
        gcInfo.put("totalGcTime", totalGcTime);
        gcInfo.put("gcDetails", gcDetails);
        return gcInfo;
    }
    // 类加载监控
    public static Map<String, Object> getClassLoadingInfo() {
        Map<String, Object> classInfo = new HashMap<>();
        ClassLoadingMXBean classLoadingMXBean = ManagementFactory.getClassLoadingMXBean();
        classInfo.put("loadedClassCount", classLoadingMXBean.getLoadedClassCount());
        classInfo.put("totalLoadedClassCount", classLoadingMXBean.getTotalLoadedClassCount());
        classInfo.put("unloadedClassCount", classLoadingMXBean.getUnloadedClassCount());
        return classInfo;
    }
    // 系统信息
    public static Map<String, Object> getSystemInfo() {
        Map<String, Object> systemInfo = new HashMap<>();
        OperatingSystemMXBean osMXBean = 
            (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
        systemInfo.put("osName", System.getProperty("os.name"));
        systemInfo.put("osVersion", System.getProperty("os.version"));
        systemInfo.put("osArch", System.getProperty("os.arch"));
        systemInfo.put("availableProcessors", osMXBean.getAvailableProcessors());
        systemInfo.put("systemLoadAverage", osMXBean.getSystemLoadAverage());
        systemInfo.put("cpuUsage", osMXBean.getSystemCpuLoad() * 100);
        systemInfo.put("processCpuUsage", osMXBean.getProcessCpuLoad() * 100);
        systemInfo.put("totalPhysicalMemory", osMXBean.getTotalPhysicalMemorySize());
        systemInfo.put("freePhysicalMemory", osMXBean.getFreePhysicalMemorySize());
        systemInfo.put("totalSwapSpace", osMXBean.getTotalSwapSpaceSize());
        systemInfo.put("freeSwapSpace", osMXBean.getFreeSwapSpaceSize());
        return systemInfo;
    }
    // 编译监控
    public static Map<String, Object> getCompilationInfo() {
        Map<String, Object> compileInfo = new HashMap<>();
        if (ManagementFactory.getCompilationMXBean() != null) {
            CompilationMXBean compilationMXBean = ManagementFactory.getCompilationMXBean();
            compileInfo.put("compilationTime", compilationMXBean.getTotalCompilationTime());
            compileInfo.put("compilerName", compilationMXBean.getName());
        }
        return compileInfo;
    }
    // 获取所有监控数据
    public static Map<String, Object> getAllMonitorInfo() {
        Map<String, Object> allInfo = new HashMap<>();
        allInfo.put("timestamp", System.currentTimeMillis());
        allInfo.put("memory", getMemoryInfo());
        allInfo.put("thread", getThreadInfo());
        allInfo.put("gc", getGCInfo());
        allInfo.put("classLoading", getClassLoadingInfo());
        allInfo.put("system", getSystemInfo());
        allInfo.put("compilation", getCompilationInfo());
        allInfo.put("runtime", getRuntimeInfo());
        return allInfo;
    }
    // JVM运行时信息
    public static Map<String, Object> getRuntimeInfo() {
        Map<String, Object> runtimeInfo = new HashMap<>();
        RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
        runtimeInfo.put("name", runtimeMXBean.getName());
        runtimeInfo.put("vmName", runtimeMXBean.getVmName());
        runtimeInfo.put("vmVersion", runtimeMXBean.getVmVersion());
        runtimeInfo.put("vmVendor", runtimeMXBean.getVmVendor());
        runtimeInfo.put("uptime", runtimeMXBean.getUptime());
        runtimeInfo.put("startTime", runtimeMXBean.getStartTime());
        // JVM参数
        List<String> inputArguments = runtimeMXBean.getInputArguments();
        runtimeInfo.put("jvmArguments", inputArguments);
        // Classpath
        runtimeInfo.put("classPath", runtimeMXBean.getClassPath());
        // 系统属性
        Map<String, String> systemProperties = runtimeMXBean.getSystemProperties();
        runtimeInfo.put("systemProperties", systemProperties);
        return runtimeInfo;
    }
}

监控数据格式化输出

JVMInfoFormatter.java

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Map;
public class JVMInfoFormatter {
    private static final SimpleDateFormat SDF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    // 格式化字节大小为可读格式
    public static String formatBytes(long bytes) {
        if (bytes == 0) return "0 B";
        final String[] units = {"B", "KB", "MB", "GB", "TB"};
        int unitIndex = (int) (Math.log10(Math.abs(bytes)) / Math.log10(1024));
        if (unitIndex >= units.length) {
            unitIndex = units.length - 1;
        }
        double value = bytes / Math.pow(1024, unitIndex);
        return String.format("%.2f %s", value, units[unitIndex]);
    }
    // 格式化内存信息
    public static String formatMemoryInfo(Map<String, Object> memoryInfo) {
        StringBuilder sb = new StringBuilder();
        sb.append("========== 内存监控 ==========\n");
        long heapMax = (Long) memoryInfo.get("heapMax");
        long heapUsed = (Long) memoryInfo.get("heapUsed");
        long heapCommitted = (Long) memoryInfo.get("heapCommitted");
        sb.append("堆内存:");
        sb.append("\n  最大: ").append(formatBytes(heapMax));
        sb.append("\n  已用: ").append(formatBytes(heapUsed));
        sb.append("\n  已分配: ").append(formatBytes(heapCommitted));
        sb.append("\n  使用率: ").append(String.format("%.2f%%", 
            heapMax > 0 ? (double) heapUsed / heapMax * 100 : 0));
        sb.append("\n\n非堆内存:");
        sb.append("\n  已用: ").append(formatBytes((Long) memoryInfo.get("nonHeapUsed")));
        sb.append("\n  已分配: ").append(formatBytes((Long) memoryInfo.get("nonHeapCommitted")));
        // 内存池详情
        @SuppressWarnings("unchecked")
        List<Map<String, Object>> pools = (List<Map<String, Object>>) memoryInfo.get("memoryPools");
        if (pools != null) {
            sb.append("\n\n内存池详情:");
            for (Map<String, Object> pool : pools) {
                sb.append("\n  ").append(pool.get("name"))
                  .append(" (").append(pool.get("type")).append("):");
                MemoryUsage usage = (MemoryUsage) pool.get("usage");
                if (usage != null) {
                    sb.append(" used=").append(formatBytes(usage.getUsed()))
                      .append(", max=").append(formatBytes(usage.getMax()))
                      .append(", committed=").append(formatBytes(usage.getCommitted()));
                }
            }
        }
        return sb.toString();
    }
    // 格式化线程信息
    public static String formatThreadInfo(Map<String, Object> threadInfo) {
        StringBuilder sb = new StringBuilder();
        sb.append("\n========== 线程监控 ==========\n");
        sb.append("当前线程数: ").append(threadInfo.get("threadCount"));
        sb.append("\n峰值线程数: ").append(threadInfo.get("peakThreadCount"));
        sb.append("\n守护线程数: ").append(threadInfo.get("daemonThreadCount"));
        sb.append("\n总启动线程数: ").append(threadInfo.get("totalStartedThreadCount"));
        sb.append("\n死锁线程数: ").append(threadInfo.get("deadlockedThreads"));
        @SuppressWarnings("unchecked")
        List<Map<String, Object>> threads = (List<Map<String, Object>>) threadInfo.get("threads");
        if (threads != null) {
            sb.append("\n\n线程状态统计:");
            Map<String, Integer> stateCount = new HashMap<>();
            for (Map<String, Object> thread : threads) {
                String state = (String) thread.get("threadState");
                stateCount.merge(state, 1, Integer::sum);
            }
            stateCount.forEach((state, count) -> 
                sb.append("\n  ").append(state).append(": ").append(count));
        }
        return sb.toString();
    }
    // 格式化GC信息
    public static String formatGCInfo(Map<String, Object> gcInfo) {
        StringBuilder sb = new StringBuilder();
        sb.append("\n========== GC监控 ==========\n");
        sb.append("总GC次数: ").append(gcInfo.get("totalGcCount"));
        sb.append("\n总GC时间: ").append(gcInfo.get("totalGcTime")).append(" ms");
        @SuppressWarnings("unchecked")
        List<Map<String, Object>> gcDetails = (List<Map<String, Object>>) gcInfo.get("gcDetails");
        if (gcDetails != null) {
            sb.append("\n\nGC详情:");
            for (Map<String, Object> gc : gcDetails) {
                sb.append("\n  ").append(gc.get("name"))
                  .append(": 次数=").append(gc.get("collectionCount"))
                  .append(", 时间=").append(gc.get("collectionTime")).append("ms");
            }
        }
        return sb.toString();
    }
    // 格式化系统信息
    public static String formatSystemInfo(Map<String, Object> systemInfo) {
        StringBuilder sb = new StringBuilder();
        sb.append("\n========== 系统信息 ==========\n");
        sb.append("操作系统: ").append(systemInfo.get("osName"))
          .append(" ").append(systemInfo.get("osVersion"));
        sb.append("\nCPU核心数: ").append(systemInfo.get("availableProcessors"));
        sb.append("\n系统负载: ").append(systemInfo.get("systemLoadAverage"));
        sb.append("\nCPU使用率: ").append(String.format("%.2f%%", 
            (Double) systemInfo.get("cpuUsage") * 100));
        sb.append("\n进程CPU使用率: ").append(String.format("%.2f%%", 
            (Double) systemInfo.get("processCpuUsage") * 100));
        sb.append("\n物理内存: 总=").append(formatBytes((Long) systemInfo.get("totalPhysicalMemory")))
          .append(", 可用=").append(formatBytes((Long) systemInfo.get("freePhysicalMemory")));
        return sb.toString();
    }
    // 格式化所有信息
    public static String formatAllInfo(Map<String, Object> allInfo) {
        StringBuilder sb = new StringBuilder();
        long timestamp = (Long) allInfo.get("timestamp");
        sb.append("===== JVM监控信息 ").append(SDF.format(new Date(timestamp))).append(" =====\n");
        // 内存
        @SuppressWarnings("unchecked")
        Map<String, Object> memoryInfo = (Map<String, Object>) allInfo.get("memory");
        sb.append(formatMemoryInfo(memoryInfo));
        // 线程
        @SuppressWarnings("unchecked")
        Map<String, Object> threadInfo = (Map<String, Object>) allInfo.get("thread");
        sb.append(formatThreadInfo(threadInfo));
        // GC
        @SuppressWarnings("unchecked")
        Map<String, Object> gcInfo = (Map<String, Object>) allInfo.get("gc");
        sb.append(formatGCInfo(gcInfo));
        // 系统
        @SuppressWarnings("unchecked")
        Map<String, Object> systemInfo = (Map<String, Object>) allInfo.get("system");
        sb.append(formatSystemInfo(systemInfo));
        // 类加载
        @SuppressWarnings("unchecked")
        Map<String, Object> classInfo = (Map<String, Object>) allInfo.get("classLoading");
        sb.append("\n========== 类加载监控 ==========\n");
        sb.append("已加载类: ").append(classInfo.get("loadedClassCount"));
        sb.append("\n总加载类: ").append(classInfo.get("totalLoadedClassCount"));
        sb.append("\n卸载类数量: ").append(classInfo.get("unloadedClassCount"));
        // JVM运行时
        @SuppressWarnings("unchecked")
        Map<String, Object> runtimeInfo = (Map<String, Object>) allInfo.get("runtime");
        sb.append("\n========== JVM运行时 ==========\n");
        sb.append("JVM名称: ").append(runtimeInfo.get("vmName"));
        sb.append("\nJVM版本: ").append(runtimeInfo.get("vmVersion"));
        sb.append("\n运行时间: ").append(formatUptime((Long) runtimeInfo.get("uptime")));
        return sb.toString();
    }
    private static String formatUptime(long uptimeMillis) {
        long days = uptimeMillis / (24 * 3600 * 1000);
        long hours = (uptimeMillis % (24 * 3600 * 1000)) / (3600 * 1000);
        long minutes = (uptimeMillis % (3600 * 1000)) / (60 * 1000);
        long seconds = (uptimeMillis % (60 * 1000)) / 1000;
        return String.format("%d天 %02d:%02d:%02d", days, hours, minutes, seconds);
    }
}

监控服务类

MonitorService.java

import java.util.Map;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Date;
public class MonitorService implements AutoCloseable {
    private final ScheduledExecutorService scheduler;
    private final long intervalSeconds;
    private PrintWriter logWriter;
    private boolean logToFile;
    public MonitorService(long intervalSeconds) {
        this.intervalSeconds = intervalSeconds;
        this.scheduler = Executors.newScheduledThreadPool(1);
    }
    public MonitorService(long intervalSeconds, String logFilePath) {
        this(intervalSeconds);
        this.logToFile = true;
        try {
            this.logWriter = new PrintWriter(new FileWriter(logFilePath, true), true);
        } catch (IOException e) {
            System.err.println("无法创建日志文件: " + e.getMessage());
            this.logToFile = false;
        }
    }
    public void start() {
        System.out.println("JVM监控服务启动，每 " + intervalSeconds + " 秒采集一次");
        scheduler.scheduleAtFixedRate(() -> {
            try {
                collectAndDisplay();
            } catch (Exception e) {
                System.err.println("监控采集失败: " + e.getMessage());
            }
        }, 0, intervalSeconds, TimeUnit.SECONDS);
    }
    private void collectAndDisplay() {
        Map<String, Object> allInfo = JVMMonitor.getAllMonitorInfo();
        String formattedInfo = JVMInfoFormatter.formatAllInfo(allInfo);
        // 控制台输出
        System.out.println(formattedInfo);
        System.out.println("========================================");
        // 文件输出
        if (logToFile && logWriter != null) {
            logWriter.println(formattedInfo);
            logWriter.println("========================================");
        }
    }
    @Override
    public void close() {
        scheduler.shutdown();
        try {
            if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
                scheduler.shutdownNow();
            }
        } catch (InterruptedException e) {
            scheduler.shutdownNow();
        }
        if (logWriter != null) {
            logWriter.close();
        }
        System.out.println("JVM监控服务已停止");
    }
}

主程序入口

Main.java

import java.util.Map;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("=== JVM监控工具 ===");
        System.out.println("1. 单次采集监控信息");
        System.out.println("2. 定时监控（默认5秒间隔）");
        System.out.println("3. 定时监控并保存日志");
        System.out.print("请选择 (1/2/3): ");
        int choice = scanner.nextInt();
        scanner.nextLine();
        switch (choice) {
            case 1:
                // 单次采集
                collectOnce();
                break;
            case 2:
                System.out.print("请输入监控间隔（秒）: ");
                long interval = scanner.nextLong();
                scanner.nextLine();
                try (MonitorService service = new MonitorService(interval)) {
                    service.start();
                    System.out.println("按回车键停止监控...");
                    scanner.nextLine();
                }
                break;
            case 3:
                System.out.print("请输入监控间隔（秒）: ");
                interval = scanner.nextLong();
                scanner.nextLine();
                System.out.print("请输入日志文件路径（如: jvm_monitor.log）: ");
                String logPath = scanner.nextLine();
                try (MonitorService service = new MonitorService(interval, logPath)) {
                    service.start();
                    System.out.println("按回车键停止监控...");
                    scanner.nextLine();
                }
                break;
            default:
                System.out.println("无效选择");
        }
        scanner.close();
    }
    private static void collectOnce() {
        System.out.println("正在采集JVM监控信息...\n");
        Map<String, Object> allInfo = JVMMonitor.getAllMonitorInfo();
        String formattedInfo = JVMInfoFormatter.formatAllInfo(allInfo);
        System.out.println(formattedInfo);
        // 显示JVM参数
        System.out.println("\n========== JVM启动参数 ==========");
        @SuppressWarnings("unchecked")
        Map<String, Object> runtimeInfo = (Map<String, Object>) allInfo.get("runtime");
        @SuppressWarnings("unchecked")
        java.util.List<String> jvmArgs = (java.util.List<String>) runtimeInfo.get("jvmArguments");
        jvmArgs.forEach(arg -> System.out.println("  " + arg));
    }
}

运行测试类

MonitorTest.java

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class MonitorTest {
    // 模拟内存使用
    private static List<byte[]> memoryLeak = new ArrayList<>();
    private static Random random = new Random();
    // 模拟线程创建
    private static List<Thread> threads = new ArrayList<>();
    public static void main(String[] args) throws Exception {
        System.out.println("启动JVM监控测试...");
        // 显示初始监控信息
        Map<String, Object> initialInfo = JVMMonitor.getAllMonitorInfo();
        System.out.println(JVMInfoFormatter.formatAllInfo(initialInfo));
        System.out.println("\n开始模拟负载...");
        // 模拟内存分配
        Thread memoryThread = new Thread(() -> {
            try {
                for (int i = 0; i < 100; i++) {
                    // 分配5MB内存
                    memoryLeak.add(new byte[5 * 1024 * 1024]);
                    System.out.println("分配内存: " + ((i + 1) * 5) + "MB");
                    Thread.sleep(500);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        memoryThread.start();
        // 模拟线程创建
        Thread threadThread = new Thread(() -> {
            try {
                for (int i = 0; i < 20; i++) {
                    Thread t = new Thread(() -> {
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    });
                    t.start();
                    threads.add(t);
                    System.out.println("创建线程: " + t.getName());
                    Thread.sleep(300);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        threadThread.start();
        // 运行10秒后显示监控信息
        Thread.sleep(10000);
        System.out.println("\n=== 运行10秒后的监控信息 ===");
        Map<String, Object> afterInfo = JVMMonitor.getAllMonitorInfo();
        System.out.println(JVMInfoFormatter.formatAllInfo(afterInfo));
        // 清理
        memoryLeak.clear();
        for (Thread t : threads) {
            t.interrupt();
        }
        // 触发GC
        System.gc();
        Thread.sleep(1000);
        System.out.println("\n=== GC后的监控信息 ===");
        Map<String, Object> gcAfterInfo = JVMMonitor.getAllMonitorInfo();
        System.out.println(JVMInfoFormatter.formatAllInfo(gcAfterInfo));
        System.out.println("\n测试完成");
    }
}

运行说明

编译和运行：

# 编译
javac -d . *.java
# 运行主程序
java Main
# 运行测试程序
java MonitorTest
# 使用JVM参数运行（推荐，便于观察）
java -Xms256m -Xmx1024m -XX:+UseG1GC -XX:+PrintGCDetails Main

输出示例：

========== 内存监控 ==========
堆内存:
  最大: 1.00 GB
  已用: 256.00 MB
  已分配: 512.00 MB
  使用率: 25.00%
========== 线程监控 ==========
当前线程数: 5
峰值线程数: 12
守护线程数: 3
========== GC监控 ==========
总GC次数: 3
总GC时间: 150 ms
========== 系统信息 ==========
操作系统: Windows 10
CPU核心数: 8
CPU使用率: 15.00%