深入理解 Java 类卸载：避免 90% 的内存泄漏问题

生产环境中，一个看似简单的类加载问题可能导致严重的内存泄漏。本文通过实际案例，深入探讨 Java 类在什么情况下会被卸载，以及如何避免类加载器导致的内存问题。

⚠️ 重要：类卸载只在 Full GC 时触发，频繁的类加载/卸载会严重影响性能

类卸载的三个必要条件

Java 类的卸载并不像对象回收那么简单。一个类要被卸载，必须同时满足以下三个条件：

类加载器层次结构

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.net.URL;
import java.net.URLClassLoader;

public class ClassLoaderHierarchy {
    private static final Logger logger = LoggerFactory.getLogger(ClassLoaderHierarchy.class);

    public static void printHierarchy() {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        StringBuilder sb = new StringBuilder();

        while (cl != null) {
            sb.append(cl.getClass().getName()).append(": ").append(cl).append("\n");
            if (cl instanceof URLClassLoader) {
                URL[] urls = ((URLClassLoader) cl).getURLs();
                for (URL url : urls) {
                    sb.append("  - ").append(url).append("\n");
                }
            }
            cl = cl.getParent();
        }
        sb.append("Bootstrap ClassLoader (null)");

        logger.info("ClassLoader Hierarchy:\n{}", sb.toString());
    }
}

Metaspace 与类卸载

Java 8+ 使用 Metaspace 替代了 PermGen，类的元数据存储在本地内存中：

import java.lang.management.*;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MetaspaceMonitor {
    private static final Logger logger = LoggerFactory.getLogger(MetaspaceMonitor.class);

    public void printMetaspaceInfo() {
        List<MemoryPoolMXBean> pools = ManagementFactory.getMemoryPoolMXBeans();
        for (MemoryPoolMXBean pool : pools) {
            if (pool.getName().contains("Metaspace")) {
                MemoryUsage usage = pool.getUsage();
                logger.info("=== Metaspace 使用情况 ===");
                logger.info("已使用: {}MB", usage.getUsed() / 1024 / 1024);
                logger.info("已提交: {}MB", usage.getCommitted() / 1024 / 1024);
                logger.info("最大值: {}",
                    usage.getMax() == -1 ? "无限制" : usage.getMax() / 1024 / 1024 + "MB");
            }
        }
    }
}

JVM 参数组合建议

public class JVMParameterCombinations {
    private static final Logger logger = LoggerFactory.getLogger(JVMParameterCombinations.class);

    public static void printRecommendedCombinations() {
        logger.info("=== 推荐的 JVM 参数组合 ===");

        logger.info("1. 开发环境（快速启动）：");
        logger.info("   -XX:+TieredCompilation");
        logger.info("   -XX:TieredStopAtLevel=1");
        logger.info("   -XX:MetaspaceSize=64M");
        logger.info("   -XX:MaxMetaspaceSize=256M");

        logger.info("2. 生产环境（稳定性优先）：");
        logger.info("   -XX:+UseG1GC");
        logger.info("   -XX:MaxGCPauseMillis=200");
        logger.info("   -XX:MetaspaceSize=256M");
        logger.info("   -XX:MaxMetaspaceSize=512M");
        logger.info("   -XX:+ParallelRefProcEnabled");

        logger.info("3. 容器环境（资源受限）：");
        logger.info("   -XX:+UseContainerSupport");
        logger.info("   -XX:MaxRAMPercentage=75.0");
        logger.info("   -XX:MaxMetaspaceSize=128M");
    }
}

现代 GC 的类卸载特性

import java.lang.management.GarbageCollectorMXBean;
import java.lang.management.ManagementFactory;

public class ModernGCClassUnloading {
    private static final Logger logger = LoggerFactory.getLogger(ModernGCClassUnloading.class);

    public static void printGCSpecificSettings() {
        String gcName = ManagementFactory.getGarbageCollectorMXBeans()
            .stream()
            .map(GarbageCollectorMXBean::getName)
            .findFirst()
            .orElse("Unknown");

        logger.info("当前 GC: {}", gcName);

        if (gcName.contains("ZGC")) {
            logger.info("ZGC 类卸载建议：");
            logger.info("-XX:+ClassUnloading (默认开启)");
            logger.info("-XX:ZUncommitDelay=300 (5分钟后释放内存)");
        } else if (gcName.contains("Shenandoah")) {
            logger.info("Shenandoah 类卸载建议：");
            logger.info("-XX:+ClassUnloadingWithConcurrentMark");
        }
    }
}

Class Data Sharing (CDS)

public class ClassDataSharing {
    private static final Logger logger = LoggerFactory.getLogger(ClassDataSharing.class);

    public static void explainCDS() {
        logger.info("=== Class Data Sharing (CDS) ===");
        logger.info("CDS 可以减少类加载时间和内存占用");
        logger.info("JDK 12+ 默认开启 AppCDS");

        logger.info("生成共享归档：");
        logger.info("java -XX:ArchiveClassesAtExit=app.jsa -cp app.jar MainClass");

        logger.info("使用共享归档：");
        logger.info("java -XX:SharedArchiveFile=app.jsa -cp app.jar MainClass");
    }
}

性能基准测试数据

场景	类数量	加载时间	卸载时间	Metaspace 增长
普通类加载	1000	245ms	89ms	12MB
动态代理（未优化）	1000	1823ms	456ms	156MB
动态代理（优化后）	1000	312ms	95ms	18MB
插件系统	100	567ms	234ms	45MB
Spring Bean 加载	500	892ms	167ms	67MB
Groovy 脚本	200	1456ms	378ms	89MB

实战案例：动态代理导致的内存泄漏

import java.net.URL;
import java.net.URLClassLoader;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;

public class DynamicProxyDemo {
    private static final Logger logger = LoggerFactory.getLogger(DynamicProxyDemo.class);

    // 错误示例：类加载器泄漏
    public static class LeakyProxyFactory {
        private static final Map<String, Object> proxyCache = new HashMap<>();

        public static Object createProxy(final Object target) {
            String key = target.getClass().getName();

            return proxyCache.computeIfAbsent(key, k -> {
                // 错误：每次创建新的URLClassLoader
                URLClassLoader loader = new URLClassLoader(
                    new URL[]{target.getClass().getProtectionDomain().getCodeSource().getLocation()},
                    target.getClass().getClassLoader()
                );

                try {
                    Class<?> clazz = loader.loadClass(target.getClass().getName());
                    return Proxy.newProxyInstance(
                        loader,
                        clazz.getInterfaces(),
                        (proxy, method, args) -> {
                            logger.debug("Before: {}", method.getName());
                            Object result = method.invoke(target, args);
                            logger.debug("After: {}", method.getName());
                            return result;
                        }
                    );
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            });
        }
    }
}

问题分析：

1. 静态 Map 持有代理对象引用，导致类加载器无法回收
2. 每次创建新的 URLClassLoader，造成类元数据重复加载
3. Metaspace 持续增长，最终导致 OutOfMemoryError

正确的实现方式

import java.lang.ref.WeakReference;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.atomic.AtomicLong;
import com.google.common.util.concurrent.Striped;
import java.text.DecimalFormat;

public class OptimizedProxyFactory {
    private static final Logger logger = LoggerFactory.getLogger(OptimizedProxyFactory.class);

    // 使用 Striped 锁减少锁竞争
    private static final Striped<Lock> locks = Striped.lock(64);
    private static final Map<ClassLoader, Map<Class<?>, WeakReference<Object>>> cache =
        new ConcurrentHashMap<>();

    // 监控指标
    private static final AtomicLong proxyCreationCount = new AtomicLong();
    private static final AtomicLong cacheHitCount = new AtomicLong();
    private static final AtomicLong cacheMissCount = new AtomicLong();

    @SuppressWarnings("unchecked")
    public static <T> T createProxy(Class<T> targetClass, T target, InvocationHandler handler) {
        ClassLoader classLoader = targetClass.getClassLoader();
        Lock lock = locks.get(classLoader);

        // 先尝试无锁读取
        Map<Class<?>, WeakReference<Object>> loaderCache = cache.get(classLoader);
        if (loaderCache != null) {
            WeakReference<Object> ref = loaderCache.get(targetClass);
            if (ref != null) {
                Object proxy = ref.get();
                if (proxy != null) {
                    cacheHitCount.incrementAndGet();
                    return (T) proxy;
                }
            }
        }

        cacheMissCount.incrementAndGet();

        // 需要创建时才加锁
        lock.lock();
        try {
            // 双重检查
            loaderCache = cache.computeIfAbsent(classLoader, k -> new ConcurrentHashMap<>());
            WeakReference<Object> ref = loaderCache.get(targetClass);
            if (ref != null) {
                Object proxy = ref.get();
                if (proxy != null) {
                    return (T) proxy;
                }
            }

            // 创建新代理
            T newProxy = (T) Proxy.newProxyInstance(
                classLoader,
                targetClass.getInterfaces(),
                handler
            );
            loaderCache.put(targetClass, new WeakReference<>(newProxy));
            proxyCreationCount.incrementAndGet();

            return newProxy;
        } finally {
            lock.unlock();
        }
    }

    public static void clearCache(ClassLoader classLoader) {
        Lock lock = locks.get(classLoader);
        lock.lock();
        try {
            cache.remove(classLoader);
        } finally {
            lock.unlock();
        }
    }

    public static void printMetrics() {
        long hits = cacheHitCount.get();
        long misses = cacheMissCount.get();
        double hitRate = (hits + misses) > 0 ?
            (double) hits / (hits + misses) * 100 : 0;

        logger.info("代理创建次数: {}", proxyCreationCount.get());
        logger.info("缓存命中率: {}%", new DecimalFormat("#.##").format(hitRate));
    }
}

批量类加载优化

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class BatchClassLoading {
    private static final Logger logger = LoggerFactory.getLogger(BatchClassLoading.class);

    // 批量加载类以减少锁竞争
    public static Map<String, Class<?>> loadClasses(
            ClassLoader loader, List<String> classNames) {
        Map<String, Class<?>> result = new ConcurrentHashMap<>();

        // 使用并行流加速加载
        classNames.parallelStream().forEach(className -> {
            try {
                Class<?> clazz = loader.loadClass(className);
                result.put(className, clazz);
            } catch (ClassNotFoundException e) {
                logger.error("Failed to load class: {}", className, e);
            }
        });

        return result;
    }
}

类加载器预热机制

public class ClassLoaderWarmup {
    private static final Logger logger = LoggerFactory.getLogger(ClassLoaderWarmup.class);

    public static void warmupClassLoader(URLClassLoader loader,
                                       List<String> criticalClasses) {
        logger.info("Warming up ClassLoader with {} classes",
            criticalClasses.size());

        long start = System.currentTimeMillis();

        for (String className : criticalClasses) {
            try {
                Class<?> clazz = loader.loadClass(className);
                // 触发类初始化
                clazz.getDeclaredConstructor().newInstance();
            } catch (Exception e) {
                logger.warn("Failed to warmup class: {}", className);
            }
        }

        long elapsed = System.currentTimeMillis() - start;
                logger.info("ClassLoader warmup completed in {} ms", elapsed);
    }
}

类卸载场景

1. Web 容器热部署

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.*;

public class WebAppLifecycle {
    private static final Logger logger = LoggerFactory.getLogger(WebAppLifecycle.class);

    private URLClassLoader appClassLoader;
    private List<Object> appInstances = new ArrayList<>();
    private List<Thread> appThreads = new ArrayList<>();

    public void deploy(String warPath) throws Exception {
        undeploy();

        File warFile = new File(warPath);
        if (!warFile.exists() || !warFile.getName().endsWith(".war")) {
            throw new IllegalArgumentException("Invalid WAR file: " + warPath);
        }

        URL[] urls = {warFile.toURI().toURL()};
        appClassLoader = new URLClassLoader(urls,
            Thread.currentThread().getContextClassLoader());

        Thread.currentThread().setContextClassLoader(appClassLoader);

        try {
            Class<?> mainClass = appClassLoader.loadClass("com.app.Main");
            Object instance = mainClass.getDeclaredConstructor().newInstance();
            appInstances.add(instance);

            Method init = mainClass.getMethod("init");
            init.invoke(instance);

            logger.info("Application deployed successfully from: {}", warPath);
        } catch (Exception e) {
            undeploy();
            throw new RuntimeException("Failed to deploy application", e);
        }
    }

    public void undeploy() {
        logger.info("Starting application undeploy...");

        stopApplicationThreads();

        for (Object instance : appInstances) {
            try {
                Method destroy = instance.getClass().getMethod("destroy");
                destroy.invoke(instance);
            } catch (Exception e) {
                logger.error("Error destroying instance", e);
            }
        }
        appInstances.clear();

        deregisterJdbcDrivers();

        if (appClassLoader != null) {
            try {
                appClassLoader.close();
            } catch (IOException e) {
                logger.error("Error closing classloader", e);
            }
            appClassLoader = null;
        }

        System.gc();
        logger.info("Application undeployed");
    }

    private void stopApplicationThreads() {
        for (Thread thread : appThreads) {
            if (thread.isAlive()) {
                thread.interrupt();
                try {
                    thread.join(5000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
        appThreads.clear();
    }

    private void deregisterJdbcDrivers() {
        Enumeration<Driver> drivers = DriverManager.getDrivers();
        while (drivers.hasMoreElements()) {
            Driver driver = drivers.nextElement();
            if (driver.getClass().getClassLoader() == appClassLoader) {
                try {
                    DriverManager.deregisterDriver(driver);
                    logger.info("Deregistered JDBC driver: {}", driver.getClass().getName());
                } catch (SQLException e) {
                    logger.error("Error deregistering driver", e);
                }
            }
        }
    }
}

2. 插件系统实现

import java.io.*;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ConcurrentHashMap;

public interface Plugin {
    void onLoad();
    void onEnable();
    void onDisable();
    void onUnload();
}

public class PluginManager {
    private static final Logger logger = LoggerFactory.getLogger(PluginManager.class);

    private final Map<String, PluginContext> plugins = new ConcurrentHashMap<>();

    enum PluginState {
        LOADED, ENABLED, DISABLED, UNLOADED
    }

    static class PluginContext {
        final URLClassLoader classLoader;
        final Plugin pluginInstance;
        final String pluginId;
        volatile PluginState state = PluginState.LOADED;

        PluginContext(String pluginId, URLClassLoader classLoader, Plugin instance) {
            this.pluginId = pluginId;
            this.classLoader = classLoader;
            this.pluginInstance = instance;
        }
    }

    public void loadPlugin(String pluginId, File jarFile) throws Exception {
        if (!jarFile.exists() || !jarFile.getName().endsWith(".jar")) {
            throw new IllegalArgumentException("Invalid plugin file: " + jarFile);
        }

        if (plugins.containsKey(pluginId)) {
            throw new IllegalStateException("Plugin already loaded: " + pluginId);
        }

        URLClassLoader classLoader = null;
        try {
            classLoader = new URLClassLoader(
                new URL[]{jarFile.toURI().toURL()},
                ClassLoader.getSystemClassLoader()
            );

            Properties props = loadPluginProperties(classLoader);
            String mainClass = props.getProperty("plugin.main");

            Class<?> pluginClass = classLoader.loadClass(mainClass);
            if (!Plugin.class.isAssignableFrom(pluginClass)) {
                throw new IllegalArgumentException("Main class must implement Plugin interface");
            }

            Plugin instance = (Plugin) pluginClass.getDeclaredConstructor().newInstance();

            PluginContext context = new PluginContext(pluginId, classLoader, instance);
            plugins.put(pluginId, context);

            instance.onLoad();
            logger.info("Plugin loaded: {}", pluginId);

        } catch (Exception e) {
            if (classLoader != null) {
                classLoader.close();
            }
            throw new RuntimeException("Failed to load plugin: " + pluginId, e);
        }
    }

    public void enablePlugin(String pluginId) {
        PluginContext context = plugins.get(pluginId);
        if (context == null) {
            throw new IllegalArgumentException("Plugin not found: " + pluginId);
        }

        if (context.state == PluginState.ENABLED) {
            return;
        }

        context.pluginInstance.onEnable();
        context.state = PluginState.ENABLED;
        logger.info("Plugin enabled: {}", pluginId);
    }

    public void disablePlugin(String pluginId) {
        PluginContext context = plugins.get(pluginId);
        if (context == null) {
            throw new IllegalArgumentException("Plugin not found: " + pluginId);
        }

        if (context.state != PluginState.ENABLED) {
            return;
        }

        context.pluginInstance.onDisable();
        context.state = PluginState.DISABLED;
        logger.info("Plugin disabled: {}", pluginId);
    }

    public void unloadPlugin(String pluginId) throws IOException {
        PluginContext context = plugins.remove(pluginId);
        if (context == null) {
            return;
        }

        try {
            if (context.state == PluginState.ENABLED) {
                context.pluginInstance.onDisable();
            }
            context.pluginInstance.onUnload();
        } finally {
            context.classLoader.close();
            context.state = PluginState.UNLOADED;
            logger.info("Plugin unloaded: {}", pluginId);
        }
    }

    private Properties loadPluginProperties(URLClassLoader classLoader) throws IOException {
        Properties props = new Properties();
        try (InputStream is = classLoader.getResourceAsStream("plugin.properties")) {
            if (is == null) {
                throw new IllegalArgumentException("plugin.properties not found");
            }
            props.load(is);
        }
        return props;
    }

    public boolean isPluginEnabled(String pluginId) {
        PluginContext context = plugins.get(pluginId);
        return context != null && context.state == PluginState.ENABLED;
    }
}

3. Java Platform Module System (JPMS)

import java.lang.module.Configuration;
import java.lang.module.ModuleFinder;
import java.nio.file.Path;
import java.util.Set;

public class ModuleClassLoading {
    private static final Logger logger = LoggerFactory.getLogger(ModuleClassLoading.class);

    public static void demonstrateModuleLayers() {
        // 创建配置
        ModuleFinder finder = ModuleFinder.of(Path.of("mods"));
        ModuleLayer parent = ModuleLayer.boot();
        Configuration cf = parent.configuration()
            .resolve(finder, ModuleFinder.of(), Set.of("com.example.app"));

        // 创建模块层，每个模块使用独立的类加载器
        ModuleLayer layer = parent.defineModulesWithManyLoaders(cf,
            ClassLoader.getSystemClassLoader());

        // 查找模块的类加载器
        Module module = layer.findModule("com.example.app").orElseThrow();
        ClassLoader moduleLoader = module.getClassLoader();

        try {
            Class<?> clazz = moduleLoader.loadClass("com.example.app.Main");
            Object instance = clazz.getDeclaredConstructor().newInstance();
            logger.info("Successfully loaded class from module: {}", clazz.getName());
        } catch (Exception e) {
            logger.error("Failed to load class from module", e);
        }
    }
}

JDK 17+ 诊断功能

public class JDK17Diagnostics {
    private static final Logger logger = LoggerFactory.getLogger(JDK17Diagnostics.class);

    public static void printProcessInfo() {
        ProcessHandle current = ProcessHandle.current();
        logger.info("PID: {}", current.pid());
        logger.info("Command: {}", current.info().command().orElse("N/A"));
        logger.info("Arguments: {}", String.join(" ",
            current.info().arguments().orElse(new String[0])));
        logger.info("Start time: {}", current.info().startInstant().orElse(null));
    }
}

监控类卸载情况

import java.lang.management.*;
import java.util.concurrent.*;
import java.lang.ref.WeakReference;

public class ClassLoadingMonitor {
    private static final Logger logger = LoggerFactory.getLogger(ClassLoadingMonitor.class);

    private final ClassLoadingMXBean classLoadingBean;
    private final MemoryMXBean memoryBean;

    public ClassLoadingMonitor() {
        this.classLoadingBean = ManagementFactory.getClassLoadingMXBean();
        this.memoryBean = ManagementFactory.getMemoryMXBean();
    }

    public void printDetailedInfo() {
        logger.info("=== 类加载统计 ===");
        logger.info("已加载类总数: {}", classLoadingBean.getTotalLoadedClassCount());
        logger.info("当前加载类数: {}", classLoadingBean.getLoadedClassCount());
        logger.info("已卸载类总数: {}", classLoadingBean.getUnloadedClassCount());

        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        logger.info("堆内存使用: {} / {}",
            formatBytes(heapUsage.getUsed()),
            formatBytes(heapUsage.getMax()));
    }

    public void enableVerboseClassLoading() {
        classLoadingBean.setVerbose(true);
        logger.info("已启用详细类加载日志");
    }

    private String formatBytes(long bytes) {
        if (bytes < 1024) return bytes + " B";
        if (bytes < 1024 * 1024) return (bytes / 1024) + " KB";
        return (bytes / 1024 / 1024) + " MB";
    }
}

// 类卸载检测工具
public class ClassUnloadingDetector {
    private static final Logger logger = LoggerFactory.getLogger(ClassUnloadingDetector.class);

    private final Map<String, WeakReference<ClassLoader>> trackedLoaders =
        new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler =
        Executors.newSingleThreadScheduledExecutor(r -> {
            Thread t = new Thread(r, "class-unloading-detector");
            t.setDaemon(true);
            return t;
        });

    public void startMonitoring() {
        scheduler.scheduleAtFixedRate(this::checkUnloadedClasses,
            0, 30, TimeUnit.SECONDS);
        logger.info("Started class unloading monitoring");
    }

    public void trackClassLoader(String name, ClassLoader loader) {
        trackedLoaders.put(name, new WeakReference<>(loader));
        logger.debug("Tracking ClassLoader: {}", name);
    }

    private void checkUnloadedClasses() {
        System.gc(); // 提示 GC

        trackedLoaders.entrySet().removeIf(entry -> {
            if (entry.getValue().get() == null) {
                logger.info("ClassLoader 已卸载: {}", entry.getKey());
                return true;
            }
            return false;
        });
    }

    public void shutdown() {
        scheduler.shutdown();
        try {
            if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
                scheduler.shutdownNow();
            }
        } catch (InterruptedException e) {
            scheduler.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

内存泄漏报告生成

import java.nio.file.*;
import java.io.*;
import java.time.Instant;
import java.util.*;

public class MemoryLeakReporter {
    private static final Logger logger = LoggerFactory.getLogger(MemoryLeakReporter.class);

    public static class LeakReport {
        private final String timestamp;
        private final long totalClasses;
        private final long unloadedClasses;
        private final Map<String, Integer> classLoaderCounts;
        private final List<String> suspiciousLoaders;

        public LeakReport(String timestamp, long totalClasses, long unloadedClasses,
                         Map<String, Integer> classLoaderCounts, List<String> suspiciousLoaders) {
            this.timestamp = timestamp;
            this.totalClasses = totalClasses;
            this.unloadedClasses = unloadedClasses;
            this.classLoaderCounts = classLoaderCounts;
            this.suspiciousLoaders = suspiciousLoaders;
        }

        // getters
        public String getTimestamp() { return timestamp; }
        public long getTotalClasses() { return totalClasses; }
        public long getUnloadedClasses() { return unloadedClasses; }
        public Map<String, Integer> getClassLoaderCounts() { return classLoaderCounts; }
        public List<String> getSuspiciousLoaders() { return suspiciousLoaders; }
    }

    public static LeakReport generateReport() {
                ClassLoadingMXBean bean = ManagementFactory.getClassLoadingMXBean();

        Map<String, Integer> loaderCounts = new HashMap<>();
        List<String> suspicious = new ArrayList<>();

        for (ClassLoader cl : DiagnosticHelper.getAllClassLoaders()) {
            String name = cl.getClass().getName();
            loaderCounts.merge(name, 1, Integer::sum);

            // 检测可疑的类加载器
            if (name.contains("RestartClassLoader") ||
                name.contains("GroovyClassLoader")) {
                suspicious.add(cl.toString());
            }
        }

        return new LeakReport(
            Instant.now().toString(),
            bean.getTotalLoadedClassCount(),
            bean.getUnloadedClassCount(),
            loaderCounts,
            suspicious
        );
    }

    public static void saveReport(LeakReport report, Path outputPath) {
        try (PrintWriter writer = new PrintWriter(
                Files.newBufferedWriter(outputPath))) {
            writer.println("=== Memory Leak Report ===");
            writer.println("Timestamp: " + report.getTimestamp());
            writer.println("Total Classes Loaded: " + report.getTotalClasses());
            writer.println("Classes Unloaded: " + report.getUnloadedClasses());
            writer.println("\nClassLoader Distribution:");
            report.getClassLoaderCounts().forEach((k, v) ->
                writer.println("  " + k + ": " + v));

            if (!report.getSuspiciousLoaders().isEmpty()) {
                writer.println("\n ⚠ Suspicious ClassLoaders:");
                report.getSuspiciousLoaders().forEach(cl ->
                    writer.println("  - " + cl));
            }

            logger.info("Report saved to: {}", outputPath);
        } catch (IOException e) {
            logger.error("Failed to save report", e);
        }
    }
}

常见的类卸载问题

1. ThreadLocal 导致的泄漏

import java.util.UUID;

public class ThreadLocalLeak {
    private static final Logger logger = LoggerFactory.getLogger(ThreadLocalLeak.class);

    private static final ThreadLocal<CustomObject> threadLocal = new ThreadLocal<>();

    static class CustomObject {
        private byte[] data = new byte[1024 * 1024]; // 1MB
        private final String id = UUID.randomUUID().toString();
    }

    public void correctUsage() {
        try {
            threadLocal.set(new CustomObject());
            // 使用ThreadLocal中的数据
            doSomething(threadLocal.get());
        } finally {
            threadLocal.remove(); // 必须清理
        }
    }

    // 更安全的封装
    public static class ThreadLocalResource implements AutoCloseable {
        private final ThreadLocal<CustomObject> tl = new ThreadLocal<>();

        public ThreadLocalResource() {
            tl.set(new CustomObject());
        }

        public CustomObject get() {
            return tl.get();
        }

        @Override
        public void close() {
            tl.remove();
            logger.debug("ThreadLocal resource cleaned");
        }
    }

    // 使用 try-with-resources 自动清理
    public void safeUsage() {
        try (ThreadLocalResource resource = new ThreadLocalResource()) {
            CustomObject obj = resource.get();
            doSomething(obj);
        }
    }

    private void doSomething(CustomObject obj) {
        logger.debug("Processing object: {}", obj.id);
    }
}

2. 注册但未注销的监听器

import java.lang.annotation.*;
import java.lang.reflect.Method;
import java.util.Set;
import java.lang.ref.WeakReference;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Subscribe {}

public class ListenerLeak {
    private static final Logger logger = LoggerFactory.getLogger(ListenerLeak.class);

    // 使用弱引用的事件总线
    public static class WeakEventBus {
        private final Map<Class<?>, Set<WeakReference<Object>>> listeners =
            new ConcurrentHashMap<>();

        public void register(Object listener) {
            Class<?> clazz = listener.getClass();
            listeners.computeIfAbsent(clazz, k -> ConcurrentHashMap.newKeySet())
                    .add(new WeakReference<>(listener));
            logger.debug("Registered listener: {}", clazz.getSimpleName());
        }

        public void post(Object event) {
            Class<?> eventType = event.getClass();
            Set<WeakReference<Object>> refs = listeners.get(eventType);
            if (refs != null) {
                // 清理已被回收的引用
                refs.removeIf(ref -> ref.get() == null);

                // 分发事件
                for (WeakReference<Object> ref : refs) {
                    Object listener = ref.get();
                    if (listener != null) {
                        invokeListener(listener, event);
                    }
                }
            }
        }

        private void invokeListener(Object listener, Object event) {
            try {
                Method[] methods = listener.getClass().getDeclaredMethods();
                for (Method method : methods) {
                    Subscribe annotation = method.getAnnotation(Subscribe.class);
                    if (annotation != null &&
                        method.getParameterCount() == 1 &&
                        method.getParameterTypes()[0].isAssignableFrom(event.getClass())) {
                        method.setAccessible(true);
                        method.invoke(listener, event);
                        logger.debug("Invoked listener method: {}", method.getName());
                    }
                }
            } catch (Exception e) {
                logger.error("Failed to invoke listener", e);
            }
        }
    }
}

3. 反射缓存导致的泄漏

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.CacheStats;
import java.time.Duration;
import java.util.Objects;

public class ReflectionCacheLeak {
    private static final Logger logger = LoggerFactory.getLogger(ReflectionCacheLeak.class);

    // 使用 Caffeine 缓存库
    public static class SafeReflectionCache {
        private static final Cache<CacheKey, Method> methodCache = Caffeine.newBuilder()
            .maximumSize(1000)
            .weakKeys()
            .weakValues()
            .expireAfterAccess(Duration.ofMinutes(10))
            .recordStats()
            .build();

        static class CacheKey {
            private final WeakReference<Class<?>> classRef;
            private final String methodName;
            private final int hashCode;

            CacheKey(Class<?> clazz, String methodName) {
                this.classRef = new WeakReference<>(clazz);
                this.methodName = methodName;
                this.hashCode = Objects.hash(clazz, methodName);
            }

            @Override
            public boolean equals(Object o) {
                if (this == o) return true;
                if (!(o instanceof CacheKey)) return false;
                CacheKey that = (CacheKey) o;
                Class<?> thisClass = classRef.get();
                Class<?> thatClass = that.classRef.get();
                return thisClass != null && thisClass.equals(thatClass)
                    && methodName.equals(that.methodName);
            }

            @Override
            public int hashCode() {
                return hashCode;
            }
        }

        public static Method getMethod(Class<?> clazz, String methodName)
                throws NoSuchMethodException {
            CacheKey key = new CacheKey(clazz, methodName);
            return methodCache.get(key, k -> {
                try {
                    return clazz.getMethod(methodName);
                } catch (NoSuchMethodException e) {
                    throw new RuntimeException(e);
                }
            });
        }

        public static void printCacheStats() {
            CacheStats stats = methodCache.stats();
            logger.info("缓存命中率: {}%", String.format("%.2f", stats.hitRate() * 100));
            logger.info("缓存大小: {}", methodCache.estimatedSize());
        }
    }
}

问题诊断与工具使用

1. 使用 jmap 分析类加载器

# 查看类加载器统计
jmap -clstats <pid>

# 生成堆转储文件
jmap -dump:format=b,file=heap.hprof <pid>

# 查看类加载器层次结构
jcmd <pid> VM.classloader_stats

# JDK 17+ 新增命令
jcmd <pid> VM.class_hierarchy

2. 程序化生成堆转储

import javax.management.*;
import java.lang.reflect.Field;
import java.util.*;

public class DiagnosticHelper {
    private static final Logger logger = LoggerFactory.getLogger(DiagnosticHelper.class);

    public static void dumpHeap(String filePath) {
        try {
            MBeanServer server = ManagementFactory.getPlatformMBeanServer();
            ObjectName mbeanName = new ObjectName("com.sun.management:type=HotSpotDiagnostic");
            server.invoke(mbeanName, "dumpHeap",
                new Object[]{filePath, Boolean.TRUE},
                new String[]{"java.lang.String", "boolean"});
            logger.info("Heap dump created: {}", filePath);
        } catch (Exception e) {
            throw new RuntimeException("Failed to dump heap", e);
        }
    }

    public static Set<ClassLoader> getAllClassLoaders() {
        Set<ClassLoader> classLoaders = new HashSet<>();

        // 通过线程获取类加载器
        for (Thread thread : Thread.getAllStackTraces().keySet()) {
            ClassLoader cl = thread.getContextClassLoader();
            if (cl != null) {
                classLoaders.add(cl);
            }
        }

        // 添加系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        classLoaders.add(systemClassLoader);
        ClassLoader parent = systemClassLoader.getParent();
        if (parent != null) {
            classLoaders.add(parent);
        }

        return classLoaders;
    }

    public static void detectClassLoaderLeaks() {
        logger.info("=== 检测类加载器泄漏 ===");

        // 强制 Full GC
        System.gc();
        System.runFinalization();
        System.gc();

        try {
            Thread.sleep(1000); // 等待GC完成
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        // 获取所有类加载器
        Set<ClassLoader> classLoaders = getAllClassLoaders();

        for (ClassLoader cl : classLoaders) {
            if (cl instanceof URLClassLoader) {
                URLClassLoader urlCl = (URLClassLoader) cl;
                logger.info("URLClassLoader: {}", cl);
                logger.info("  URLs: {}", Arrays.toString(urlCl.getURLs()));
                logger.info("  Parent: {}", cl.getParent());

                // 检查是否应该被回收但仍然存活
                if (shouldBeGarbageCollected(cl)) {
                    logger.warn("  ⚠ 潜在泄漏：此类加载器应该已被回收");
                }
            }
        }
    }

    private static boolean shouldBeGarbageCollected(ClassLoader cl) {
        // 检查是否是应该被回收的类加载器（如已关闭的Web应用）
        String className = cl.getClass().getName();
        return className.contains("WebappClassLoader") ||
               className.contains("PluginClassLoader");
    }
}

3. Spring 框架中的类加载器问题

import org.springframework.beans.factory.DisposableBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextClosedEvent;
import org.springframework.stereotype.Component;
import java.lang.reflect.Field;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

@Component
public class SpringClassLoaderIssues {
    private static final Logger logger = LoggerFactory.getLogger(SpringClassLoaderIssues.class);

    @Configuration
    @ConditionalOnClass(name = "org.springframework.boot.devtools.restart.Restarter")
    public static class DevToolsConfiguration {

        @Bean
        public ApplicationListener<ContextClosedEvent> classLoaderCleanupListener() {
            return event -> {
                logger.info("Cleaning up RestartClassLoader resources");
                cleanupRestartClassLoader();
            };
        }

        private void cleanupRestartClassLoader() {
            try {
                // 清理 Spring DevTools 的缓存
                Field cacheField = Class.forName(
                    "org.springframework.boot.devtools.restart.classloader.RestartClassLoader")
                    .getDeclaredField("cache");
                cacheField.setAccessible(true);

                // 获取所有 RestartClassLoader 实例并清理
                for (ClassLoader cl : DiagnosticHelper.getAllClassLoaders()) {
                    if (cl.getClass().getName().contains("RestartClassLoader")) {
                        Object cache = cacheField.get(cl);
                        if (cache instanceof Map) {
                            ((Map<?, ?>) cache).clear();
                            logger.debug("Cleared RestartClassLoader cache");
                        }
                    }
                }
            } catch (Exception e) {
                logger.debug("DevTools not in use or cache clearing failed", e);
            }
        }
    }

    @Component
    public static class ScheduledTaskManager implements DisposableBean {
        private final ScheduledExecutorService executor =
            Executors.newScheduledThreadPool(5, r -> {
                Thread t = new Thread(r);
                t.setDaemon(true);
                t.setName("scheduled-task-" + t.getId());
                return t;
            });

        @Override
        public void destroy() {
            logger.info("Shutting down scheduled task executor");
            executor.shutdown();
            try {
                if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
                    executor.shutdownNow();
                    logger.warn("Forced shutdown of scheduled task executor");
                }
            } catch (InterruptedException e) {
                executor.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }
    }
}

异常处理和自动修复建议

public class ClassLoaderExceptionHandler {
    private static final Logger logger = LoggerFactory.getLogger(ClassLoaderExceptionHandler.class);

        public static void handleClassLoaderException(Exception e) {
        if (e instanceof LinkageError) {
            logger.error("类链接错误，可能存在版本冲突");
            logger.error("建议检查：");
            logger.error("1. 是否有重复的JAR包");
            logger.error("2. 类路径中是否有不同版本的相同库");
            logger.error("3. 使用 mvn dependency:tree 分析依赖冲突");
        } else if (e instanceof ClassCircularityError) {
            logger.error("类循环依赖错误");
            logger.error("建议检查类的继承和实现关系");
        } else if (e instanceof NoClassDefFoundError) {
            logger.error("类定义未找到，检查类路径");
            printClassPath();
        } else if (e instanceof OutOfMemoryError && e.getMessage().contains("Metaspace")) {
            logger.error("Metaspace 内存溢出");
            handleMetaspaceOOM();
        }
    }

    private static void printClassPath() {
        String classPath = System.getProperty("java.class.path");
        logger.info("当前类路径：");
        for (String path : classPath.split(File.pathSeparator)) {
            logger.info("  - {}", path);
        }
    }

    private static void handleMetaspaceOOM() {
        logger.error("处理建议：");
        logger.error("1. 增加 -XX:MaxMetaspaceSize 参数");
        logger.error("2. 检查是否有类加载器泄漏");
        logger.error("3. 运行 jmap -clstats <pid> 查看详情");

        // 尝试清理
        System.gc();
        logger.info("已触发 Full GC 尝试释放 Metaspace");
    }
}

public class AutoFixSuggestions {
    private static final Logger logger = LoggerFactory.getLogger(AutoFixSuggestions.class);

    public static List<String> analyzeProblem(Throwable error) {
        List<String> suggestions = new ArrayList<>();

        if (error instanceof OutOfMemoryError) {
            String message = error.getMessage();
            if (message != null && message.contains("Metaspace")) {
                suggestions.add("增加 -XX:MaxMetaspaceSize 参数");
                suggestions.add("检查是否有类加载器泄漏");
                suggestions.add("运行 jmap -clstats <pid> 查看详情");
            }
        } else if (error instanceof ClassNotFoundException) {
            suggestions.add("检查类路径配置");
            suggestions.add("确认 JAR 文件完整性");
            suggestions.add("检查模块依赖关系");
        }

        return suggestions;
    }

    public static void printSuggestions(Throwable error) {
        List<String> suggestions = analyzeProblem(error);
        if (!suggestions.isEmpty()) {
            logger.info("=== 修复建议 ===");
            suggestions.forEach(s -> logger.info("- {}", s));
        }
    }
}

性能影响分析

类卸载对性能的影响

public class ClassUnloadingPerformance {
    private static final Logger logger = LoggerFactory.getLogger(ClassUnloadingPerformance.class);

    public static void measureClassUnloadingImpact() {
        logger.info("=== 类卸载性能测试 ===");

        long initialClasses = getLoadedClassCount();
        List<Long> gcTimes = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            // 加载类
            List<ClassLoader> loaders = createClassLoaders(100);

            // 清除引用
            loaders.clear();

            // 测量GC时间
            long gcTime = measureGCTime();
            gcTimes.add(gcTime);

            logger.info("第 {} 次迭代 - GC时间: {} ms, 当前类数: {}",
                i + 1, gcTime, getLoadedClassCount());
        }

        double avgGCTime = gcTimes.stream()
            .mapToLong(Long::longValue)
            .average()
            .orElse(0);

        logger.info("平均GC时间: {} ms", String.format("%.2f", avgGCTime));
        logger.info("类卸载数量: {}",
            initialClasses + 1000 - getLoadedClassCount());
    }

    private static List<ClassLoader> createClassLoaders(int count) {
        List<ClassLoader> loaders = new ArrayList<>();

        for (int i = 0; i < count; i++) {
            URLClassLoader loader = new URLClassLoader(new URL[0]);
            loaders.add(loader);
        }

        return loaders;
    }

    private static long measureGCTime() {
        long startTime = System.currentTimeMillis();
        System.gc();
        return System.currentTimeMillis() - startTime;
    }

    private static long getLoadedClassCount() {
        return ManagementFactory.getClassLoadingMXBean().getLoadedClassCount();
    }
}

Metaspace 配置建议

public class MetaspaceOptimization {
    private static final Logger logger = LoggerFactory.getLogger(MetaspaceOptimization.class);

    public static void recommendSettings() {
        Runtime runtime = Runtime.getRuntime();
        long maxMemory = runtime.maxMemory();

        logger.info("=== Metaspace 配置建议 ===");

        long recommendedMetaspaceSize = maxMemory / 8;
        long recommendedMaxMetaspaceSize = maxMemory / 4;

        logger.info("推荐 JVM 参数：");
        logger.info("-XX:MetaspaceSize={}M", recommendedMetaspaceSize / 1024 / 1024);
        logger.info("-XX:MaxMetaspaceSize={}M", recommendedMaxMetaspaceSize / 1024 / 1024);

        logger.info("特定场景建议：");
        logger.info("1. 微服务应用：");
        logger.info("   -XX:MaxMetaspaceSize=128M");
        logger.info("   -XX:CompressedClassSpaceSize=64M");

        logger.info("2. 应用服务器（Tomcat/Jetty）：");
        logger.info("   -XX:MaxMetaspaceSize=512M");
        logger.info("   -XX:+UseStringDeduplication");

        logger.info("3. 使用动态语言（Groovy/JRuby）：");
        logger.info("   -XX:MaxMetaspaceSize=1G");
        logger.info("   -XX:+UnlockExperimentalVMOptions");
        logger.info("   -XX:+UseG1GC");

        logger.info("监控参数：");
        logger.info("   -XX:+TraceClassLoading");
        logger.info("   -XX:+TraceClassUnloading");
        logger.info("   -Xlog:class+unload=info (JDK 9+)");
    }
}

配置文件示例

application.yml 配置

# application.yml 示例
jvm:
  metaspace:
    initial-size: 128M
    max-size: 512M
  class-loading:
    trace-loading: true
    trace-unloading: true
  gc:
    type: G1
    max-pause-millis: 200

# 监控配置
monitoring:
  class-loader:
    check-interval: 30s
    leak-detection: true
    report-path: /var/log/app/classloader-reports

Docker 环境配置

FROM openjdk:17-jdk-slim

# 设置 JVM 参数
ENV JAVA_OPTS="-XX:MaxMetaspaceSize=256m \
               -XX:MetaspaceSize=128m \
               -XX:+TraceClassLoading \
               -XX:+TraceClassUnloading \
               -XX:+UseG1GC \
               -XX:MaxGCPauseMillis=200"

# 添加监控脚本
COPY scripts/monitor-metaspace.sh /usr/local/bin/
RUN chmod +x /usr/local/bin/monitor-metaspace.sh

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s \
  CMD jcmd 1 VM.metaspace || exit 1

COPY target/app.jar /app.jar
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar /app.jar"]

安全性考虑

import java.security.CodeSource;
import java.security.PermissionCollection;
import java.security.Permissions;

public class SecureClassLoading {
    private static final Logger logger = LoggerFactory.getLogger(SecureClassLoading.class);

    public static URLClassLoader createSecureClassLoader(URL[] urls) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkCreateClassLoader();
        }

        return new URLClassLoader(urls) {
            @Override
            protected PermissionCollection getPermissions(CodeSource codesource) {
                PermissionCollection perms = super.getPermissions(codesource);
                perms.add(new RuntimePermission("accessDeclaredMembers"));
                return perms;
            }
        };
    }
}

测试验证

import static org.junit.Assert.*;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import java.io.File;

@RunWith(JUnit4.class)
public class ClassUnloadingTest {
    private static final Logger logger = LoggerFactory.getLogger(ClassUnloadingTest.class);

    @Test
    public void testClassUnloading() throws Exception {
        WeakReference<Class<?>> classRef = loadClassInIsolation();

        // 触发 GC
        System.gc();
        Thread.sleep(100);
        System.gc();

        // 验证类已被卸载
        assertNull("Class should be unloaded", classRef.get());
        logger.info("Class unloading test passed");
    }

    private WeakReference<Class<?>> loadClassInIsolation() throws Exception {
        URLClassLoader loader = new URLClassLoader(
            new URL[]{new File("test-classes").toURI().toURL()});
        Class<?> clazz = loader.loadClass("TestClass");
        loader.close();
        return new WeakReference<>(clazz);
    }

    @Test
    public void testPluginLifecycle() throws Exception {
        PluginManager manager = new PluginManager();

        // 创建测试插件JAR
        File pluginJar = createTestPluginJar();

        // 加载插件
        manager.loadPlugin("test-plugin", pluginJar);

        // 启用插件
        manager.enablePlugin("test-plugin");

        // 验证插件状态
        assertTrue(manager.isPluginEnabled("test-plugin"));

        // 卸载插件
        manager.unloadPlugin("test-plugin");

        // 验证类已卸载
        System.gc();
        Thread.sleep(100);

        // 验证插件已被移除
        assertFalse(manager.isPluginEnabled("test-plugin"));
    }

    private File createTestPluginJar() throws Exception {
        // 创建临时目录
        Path tempDir = Files.createTempDirectory("test-plugin");

        // 编译 TestPlugin.java
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        compiler.run(null, null, null,
            "src/test/java/com/example/TestPlugin.java",
            "-d", tempDir.toString());

        // 创建 plugin.properties
        Path propsFile = tempDir.resolve("plugin.properties");
        Files.write(propsFile, Arrays.asList(
            "plugin.main=com.example.TestPlugin",
            "plugin.name=Test Plugin",
            "plugin.version=1.0.0"
        ));

        // 打包成 JAR
        File jarFile = File.createTempFile("test-plugin", ".jar");
        // ... JAR 打包逻辑

        return jarFile;
    }
}

快速参考

紧急情况处理

1. OutOfMemoryError: Metaspace

   # 临时增加 Metaspace
   -XX:MaxMetaspaceSize=1G
   
   # 查看类加载情况
   jcmd <pid> VM.classloader_stats

2. 类加载器泄漏检测

   # 生成堆转储
   jmap -dump:format=b,file=heap.hprof <pid>
   
   # 使用 MAT 分析
   # 查找路径：ClassLoader -> GC Roots

性能调优

• ✓ 设置合理的 Metaspace 大小
• ✓ 启用类卸载日志监控
• ✓ 定期检查类加载器数量
• ✓ 实现资源清理钩子
• ✓ 使用弱引用缓存

故障排查

1. 检查类加载器引用

• 静态变量是否持有类实例
• ThreadLocal 是否已清理
• 监听器是否已注销

2. 监控 Metaspace

• 使用 -XX:+TraceClassUnloading 查看卸载日志
• 定期检查 Metaspace 使用率
• 设置合理的 MaxMetaspaceSize

3. 分析堆转储

• 使用 MAT 查找 ClassLoader 泄漏
• 检查 GC Roots 路径
• 分析大对象和重复类

4. 代码审查重点

• 动态代理和反射使用
• 自定义类加载器实现
• 资源清理逻辑

常见错误信息处理

1. java.lang.OutOfMemoryError: Metaspace

// 解决方案：增加 Metaspace 大小或查找类加载器泄漏
// -XX:MaxMetaspaceSize=512M
// 使用 jmap -clstats <pid> 查看类加载器统计

2. java.lang.ClassNotFoundException 在热部署时

// 确保正确设置线程上下文类加载器
Thread.currentThread().setContextClassLoader(newClassLoader);

最佳方案总结

场景	问题	解决方案	监控方法
动态代理	静态缓存持有代理对象	使用 WeakReference 和 Striped 锁	监控 Metaspace 使用率
热部署	ClassLoader 未正确释放	清理所有引用并调用 close()	jmap -clstats
插件系统	跨 ClassLoader 引用	使用接口隔离	MAT 分析 GC Roots
ThreadLocal	线程池环境下内存泄漏	使用后调用 remove()	线程转储分析
事件监听	注册后未注销	使用弱引用	监控引用数量
Spring 应用	线程池未关闭	实现 DisposableBean	Spring Actuator

💡 关键提醒：

1. 类卸载只在 Full GC 时发生
2. Metaspace 不会自动收缩，需要合理设置最大值
3. 生产环境建议开启类卸载日志进行监控
4. GraalVM Native Image 不存在运行时类加载和卸载，但可通过特定配置实现有限的动态特性

相关工具资源

• MAT (Memory Analyzer Tool) : www.eclipse.org/mat/
• VisualVM : visualvm.github.io/
• Async Profiler : github.com/jvm-profili...

问题诊断流程图

监控脚本示例

monitor-metaspace.sh

#!/bin/bash
# Metaspace 监控脚本

PID=$1
if [ -z "$PID" ]; then
    echo "Usage: $0 <pid>"
    exit 1
fi

while true; do
    echo "=== Metaspace Monitor - $(date) ==="

    # 获取 Metaspace 使用情况
    jcmd $PID VM.metaspace | grep -E "Used:|Committed:|Reserved:"

    # 获取类加载统计
    echo ""
    echo "Class Loading Stats:"
    jcmd $PID VM.classloader_stats | head -20

    # 检查是否有异常
    METASPACE_USED=$(jcmd $PID VM.metaspace | grep "Used:" | awk '{print $2}' | sed 's/K//')
    METASPACE_MAX=$(jcmd $PID VM.flags | grep MaxMetaspaceSize | awk '{print $3}')

    if [ ! -z "$METASPACE_MAX" ] && [ "$METASPACE_MAX" != "0" ]; then
        USAGE_PERCENT=$((METASPACE_USED * 100 / (METASPACE_MAX / 1024)))
        if [ $USAGE_PERCENT -gt 80 ]; then
            echo "WARNING: Metaspace usage is at ${USAGE_PERCENT}%"
        fi
    fi

    echo "----------------------------------------"
    sleep 30
done

完整的测试插件示例

TestPlugin.java

// 用于测试的插件实现
public class TestPlugin implements Plugin {
    private static final Logger logger = LoggerFactory.getLogger(TestPlugin.class);

    private volatile boolean running = false;
    private Thread workerThread;

    @Override
    public void onLoad() {
        logger.info("TestPlugin loaded");
    }

    @Override
    public void onEnable() {
        logger.info("TestPlugin enabled");
        running = true;

        workerThread = new Thread(() -> {
            while (running) {
                try {
                    logger.debug("TestPlugin is working...");
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        });
        workerThread.setName("TestPlugin-Worker");
        workerThread.start();
    }

    @Override
    public void onDisable() {
        logger.info("TestPlugin disabled");
        running = false;
        if (workerThread != null) {
            workerThread.interrupt();
            try {
                workerThread.join(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    @Override
    public void onUnload() {
        logger.info("TestPlugin unloaded");
        // 清理资源
    }
}

plugin.properties

# 插件配置文件
plugin.main=com.example.TestPlugin
plugin.name=Test Plugin
plugin.version=1.0.0
plugin.author=Your Name
plugin.description=A test plugin for demonstrating class loading

生产环境监控配置

Prometheus 监控指标

import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Gauge;

@Component
public class ClassLoaderMetrics {
    private final ClassLoadingMXBean classLoadingBean;

    public ClassLoaderMetrics(MeterRegistry registry) {
        this.classLoadingBean = ManagementFactory.getClassLoadingMXBean();

        // 注册监控指标
        Gauge.builder("jvm.classes.loaded", classLoadingBean,
            ClassLoadingMXBean::getLoadedClassCount)
            .description("Number of classes currently loaded")
            .register(registry);

        Gauge.builder("jvm.classes.unloaded", classLoadingBean,
            ClassLoadingMXBean::getUnloadedClassCount)
            .description("Total number of classes unloaded")
            .register(registry);

        // Metaspace 监控
        List<MemoryPoolMXBean> pools = ManagementFactory.getMemoryPoolMXBeans();
        for (MemoryPoolMXBean pool : pools) {
            if (pool.getName().contains("Metaspace")) {
                Gauge.builder("jvm.metaspace.used", pool,
                    p -> p.getUsage().getUsed())
                    .description("Metaspace used memory")
                    .baseUnit("bytes")
                    .register(registry);

                Gauge.builder("jvm.metaspace.committed", pool,
                    p -> p.getUsage().getCommitted())
                    .description("Metaspace committed memory")
                    .baseUnit("bytes")
                    .register(registry);
            }
        }
    }
}

Grafana Dashboard 配置

{
  "dashboard": {
    "title": "JVM Class Loading Monitor",
    "panels": [
      {
        "title": "Classes Loaded",
        "targets": [
          {
            "expr": "jvm_classes_loaded"
          }
        ]
      },
      {
        "title": "Metaspace Usage",
        "targets": [
          {
            "expr": "jvm_metaspace_used / jvm_metaspace_committed * 100"
          }
        ]
      },
      {
        "title": "Class Unload Rate",
        "targets": [
          {
            "expr": "rate(jvm_classes_unloaded[5m])"
          }
        ]
      }
    ]
  }
}