第206集JVM内存模型深度解析与Full GC优化实战：堆栈分离、方法区优化、直接内存管理的架构级解决方案

// 智能堆内存管理器
@Component
@Slf4j
public class IntelligentHeapMemoryManager {
    
    private final YoungGenerationManager youngGenManager;
    private final OldGenerationManager oldGenManager;
    private final MetaspaceManager metaspaceManager;
    private final MeterRegistry meterRegistry;
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(5);
    
    public IntelligentHeapMemoryManager(YoungGenerationManager youngGenManager,
                                       OldGenerationManager oldGenManager,
                                       MetaspaceManager metaspaceManager,
                                       MeterRegistry meterRegistry) {
        this.youngGenManager = youngGenManager;
        this.oldGenManager = oldGenManager;
        this.metaspaceManager = metaspaceManager;
        this.meterRegistry = meterRegistry;
        
        // 启动堆内存管理
        startHeapMemoryManagement();
    }
    
    // 启动堆内存管理
    private void startHeapMemoryManagement() {
        // 定期监控堆内存使用
        scheduler.scheduleAtFixedRate(() -> {
            try {
                monitorHeapMemoryUsage();
            } catch (Exception e) {
                log.error("Error monitoring heap memory usage", e);
            }
        }, 0, 1, TimeUnit.SECONDS);
        
        // 定期优化堆内存分配
        scheduler.scheduleAtFixedRate(() -> {
            try {
                optimizeHeapMemoryAllocation();
            } catch (Exception e) {
                log.error("Error optimizing heap memory allocation", e);
            }
        }, 0, 30, TimeUnit.SECONDS);
        
        // 定期清理堆内存
        scheduler.scheduleAtFixedRate(() -> {
            try {
                performHeapMemoryCleanup();
            } catch (Exception e) {
                log.error("Error performing heap memory cleanup", e);
            }
        }, 0, 5, TimeUnit.MINUTES);
    }
    
    // 监控堆内存使用
    public void monitorHeapMemoryUsage() {
        try {
            // 获取堆内存使用信息
            HeapMemoryInfo heapInfo = getHeapMemoryInfo();
            
            // 分析堆内存使用模式
            HeapUsagePattern pattern = analyzeHeapUsagePattern(heapInfo);
            
            // 检测堆内存异常
            detectHeapMemoryAnomalies(heapInfo, pattern);
            
            // 更新指标
            updateHeapMemoryMetrics(heapInfo);
            
        } catch (Exception e) {
            log.error("Error monitoring heap memory usage", e);
            meterRegistry.counter("heap.monitoring.error").increment();
        }
    }
    
    // 获取堆内存信息
    private HeapMemoryInfo getHeapMemoryInfo() {
        HeapMemoryInfo info = new HeapMemoryInfo();
        
        // 获取堆内存使用
        MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        
        info.setUsed(heapUsage.getUsed());
        info.setMax(heapUsage.getMax());
        info.setCommitted(heapUsage.getCommitted());
        info.setInit(heapUsage.getInit());
        
        // 获取新生代信息
        YoungGenerationInfo youngInfo = youngGenManager.getYoungGenerationInfo();
        info.setYoungGenerationInfo(youngInfo);
        
        // 获取老年代信息
        OldGenerationInfo oldInfo = oldGenManager.getOldGenerationInfo();
        info.setOldGenerationInfo(oldInfo);
        
        // 获取元空间信息
        MetaspaceInfo metaspaceInfo = metaspaceManager.getMetaspaceInfo();
        info.setMetaspaceInfo(metaspaceInfo);
        
        return info;
    }
    
    // 分析堆内存使用模式
    private HeapUsagePattern analyzeHeapUsagePattern(HeapMemoryInfo heapInfo) {
        HeapUsagePattern pattern = new HeapUsagePattern();
        
        // 计算堆内存使用率
        double usageRatio = (double) heapInfo.getUsed() / heapInfo.getMax();
        pattern.setUsageRatio(usageRatio);
        
        // 分析新生代使用模式
        YoungGenerationUsagePattern youngPattern = analyzeYoungGenerationPattern(heapInfo.getYoungGenerationInfo());
        pattern.setYoungGenerationPattern(youngPattern);
        
        // 分析老年代使用模式
        OldGenerationUsagePattern oldPattern = analyzeOldGenerationPattern(heapInfo.getOldGenerationInfo());
        pattern.setOldGenerationPattern(oldPattern);
        
        // 分析元空间使用模式
        MetaspaceUsagePattern metaspacePattern = analyzeMetaspacePattern(heapInfo.getMetaspaceInfo());
        pattern.setMetaspacePattern(metaspacePattern);
        
        // 计算内存分配速率
        double allocationRate = calculateAllocationRate(heapInfo);
        pattern.setAllocationRate(allocationRate);
        
        // 计算内存回收速率
        double collectionRate = calculateCollectionRate(heapInfo);
        pattern.setCollectionRate(collectionRate);
        
        return pattern;
    }
    
    // 分析新生代使用模式
    private YoungGenerationUsagePattern analyzeYoungGenerationPattern(YoungGenerationInfo youngInfo) {
        YoungGenerationUsagePattern pattern = new YoungGenerationUsagePattern();
        
        // 分析Eden区使用
        double edenUsageRatio = (double) youngInfo.getEdenUsed() / youngInfo.getEdenMax();
        pattern.setEdenUsageRatio(edenUsageRatio);
        
        // 分析Survivor区使用
        double survivorUsageRatio = (double) youngInfo.getSurvivorUsed() / youngInfo.getSurvivorMax();
        pattern.setSurvivorUsageRatio(survivorUsageRatio);
        
        // 分析对象晋升率
        double promotionRate = calculatePromotionRate(youngInfo);
        pattern.setPromotionRate(promotionRate);
        
        // 分析Minor GC频率
        double minorGCFrequency = calculateMinorGCFrequency(youngInfo);
        pattern.setMinorGCFrequency(minorGCFrequency);
        
        return pattern;
    }
    
    // 分析老年代使用模式
    private OldGenerationUsagePattern analyzeOldGenerationPattern(OldGenerationInfo oldInfo) {
        OldGenerationUsagePattern pattern = new OldGenerationUsagePattern();
        
        // 分析老年代使用率
        double usageRatio = (double) oldInfo.getUsed() / oldInfo.getMax();
        pattern.setUsageRatio(usageRatio);
        
        // 分析Full GC频率
        double fullGCFrequency = calculateFullGCFrequency(oldInfo);
        pattern.setFullGCFrequency(fullGCFrequency);
        
        // 分析对象存活率
        double survivalRate = calculateSurvivalRate(oldInfo);
        pattern.setSurvivalRate(survivalRate);
        
        // 分析内存碎片化程度
        double fragmentationRatio = calculateFragmentationRatio(oldInfo);
        pattern.setFragmentationRatio(fragmentationRatio);
        
        return pattern;
    }
    
    // 分析元空间使用模式
    private MetaspaceUsagePattern analyzeMetaspacePattern(MetaspaceInfo metaspaceInfo) {
        MetaspaceUsagePattern pattern = new MetaspaceUsagePattern();
        
        // 分析元空间使用率
        double usageRatio = (double) metaspaceInfo.getUsed() / metaspaceInfo.getMax();
        pattern.setUsageRatio(usageRatio);
        
        // 分析类加载速率
        double classLoadingRate = calculateClassLoadingRate(metaspaceInfo);
        pattern.setClassLoadingRate(classLoadingRate);
        
        // 分析类卸载速率
        double classUnloadingRate = calculateClassUnloadingRate(metaspaceInfo);
        pattern.setClassUnloadingRate(classUnloadingRate);
        
        return pattern;
    }
    
    // 计算内存分配速率
    private double calculateAllocationRate(HeapMemoryInfo heapInfo) {
        // 这里可以根据历史数据计算内存分配速率
        return 100.0; // 模拟100MB/s
    }
    
    // 计算内存回收速率
    private double calculateCollectionRate(HeapMemoryInfo heapInfo) {
        // 这里可以根据GC历史数据计算内存回收速率
        return 80.0; // 模拟80MB/s
    }
    
    // 计算对象晋升率
    private double calculatePromotionRate(YoungGenerationInfo youngInfo) {
        // 计算从新生代晋升到老年代的对象比例
        return 0.1; // 模拟10%
    }
    
    // 计算Minor GC频率
    private double calculateMinorGCFrequency(YoungGenerationInfo youngInfo) {
        // 计算Minor GC的频率
        return 5.0; // 模拟每分钟5次
    }
    
    // 计算Full GC频率
    private double calculateFullGCFrequency(OldGenerationInfo oldInfo) {
        // 计算Full GC的频率
        return 0.1; // 模拟每分钟0.1次
    }
    
    // 计算对象存活率
    private double calculateSurvivalRate(OldGenerationInfo oldInfo) {
        // 计算老年代对象的存活率
        return 0.8; // 模拟80%
    }
    
    // 计算内存碎片化程度
    private double calculateFragmentationRatio(OldGenerationInfo oldInfo) {
        // 计算内存碎片化程度
        return 0.2; // 模拟20%
    }
    
    // 计算类加载速率
    private double calculateClassLoadingRate(MetaspaceInfo metaspaceInfo) {
        // 计算类加载速率
        return 10.0; // 模拟每秒10个类
    }
    
    // 计算类卸载速率
    private double calculateClassUnloadingRate(MetaspaceInfo metaspaceInfo) {
        // 计算类卸载速率
        return 2.0; // 模拟每秒2个类
    }
    
    // 检测堆内存异常
    private void detectHeapMemoryAnomalies(HeapMemoryInfo heapInfo, HeapUsagePattern pattern) {
        // 检测堆内存使用率过高
        if (pattern.getUsageRatio() > 0.9) {
            log.warn("Heap memory usage is high: {}%", pattern.getUsageRatio() * 100);
            triggerHeapMemoryAlert(AlertSeverity.CRITICAL, "High heap memory usage");
        } else if (pattern.getUsageRatio() > 0.8) {
            log.warn("Heap memory usage is moderate: {}%", pattern.getUsageRatio() * 100);
            triggerHeapMemoryAlert(AlertSeverity.WARNING, "Moderate heap memory usage");
        }
        
        // 检测新生代异常
        YoungGenerationUsagePattern youngPattern = pattern.getYoungGenerationPattern();
        if (youngPattern.getEdenUsageRatio() > 0.9) {
            log.warn("Eden space usage is high: {}%", youngPattern.getEdenUsageRatio() * 100);
            triggerHeapMemoryAlert(AlertSeverity.WARNING, "High Eden space usage");
        }
        
        // 检测老年代异常
        OldGenerationUsagePattern oldPattern = pattern.getOldGenerationPattern();
        if (oldPattern.getUsageRatio() > 0.8) {
            log.warn("Old generation usage is high: {}%", oldPattern.getUsageRatio() * 100);
            triggerHeapMemoryAlert(AlertSeverity.WARNING, "High old generation usage");
        }
        
        // 检测Full GC频率过高
        if (oldPattern.getFullGCFrequency() > 1.0) {
            log.warn("Full GC frequency is high: {} per minute", oldPattern.getFullGCFrequency());
            triggerHeapMemoryAlert(AlertSeverity.CRITICAL, "High Full GC frequency");
        }
        
        // 检测元空间异常
        MetaspaceUsagePattern metaspacePattern = pattern.getMetaspacePattern();
        if (metaspacePattern.getUsageRatio() > 0.8) {
            log.warn("Metaspace usage is high: {}%", metaspacePattern.getUsageRatio() * 100);
            triggerHeapMemoryAlert(AlertSeverity.WARNING, "High metaspace usage");
        }
    }
    
    // 触发堆内存告警
    private void triggerHeapMemoryAlert(AlertSeverity severity, String message) {
        try {
            Alert alert = Alert.builder()
                    .title("Heap Memory Alert")
                    .description(message)
                    .severity(severity)
                    .timestamp(System.currentTimeMillis())
                    .build();
            
            // 这里可以发送到告警系统
            log.info("Heap memory alert triggered: {}", alert);
            
            meterRegistry.counter("heap.alert.triggered")
                    .tag("severity", severity.name())
                    .increment();
            
        } catch (Exception e) {
            log.error("Error triggering heap memory alert", e);
        }
    }
    
    // 优化堆内存分配
    public void optimizeHeapMemoryAllocation() {
        log.info("Optimizing heap memory allocation");
        
        try {
            // 获取当前堆内存信息
            HeapMemoryInfo heapInfo = getHeapMemoryInfo();
            HeapUsagePattern pattern = analyzeHeapUsagePattern(heapInfo);
            
            // 优化新生代分配
            optimizeYoungGenerationAllocation(pattern.getYoungGenerationPattern());
            
            // 优化老年代分配
            optimizeOldGenerationAllocation(pattern.getOldGenerationPattern());
            
            // 优化元空间分配
            optimizeMetaspaceAllocation(pattern.getMetaspacePattern());
            
            meterRegistry.counter("heap.optimization.success").increment();
            
        } catch (Exception e) {
            log.error("Error optimizing heap memory allocation", e);
            meterRegistry.counter("heap.optimization.error").increment();
        }
    }
    
    // 优化新生代分配
    private void optimizeYoungGenerationAllocation(YoungGenerationUsagePattern pattern) {
        if (pattern.getEdenUsageRatio() > 0.8) {
            // Eden区使用率过高，建议增加新生代大小
            log.info("Suggesting to increase young generation size due to high Eden usage");
        }
        
        if (pattern.getPromotionRate() > 0.2) {
            // 对象晋升率过高，建议调整新生代参数
            log.info("Suggesting to adjust young generation parameters due to high promotion rate");
        }
        
        if (pattern.getMinorGCFrequency() > 10) {
            // Minor GC频率过高，建议优化新生代配置
            log.info("Suggesting to optimize young generation configuration due to high Minor GC frequency");
        }
    }
    
    // 优化老年代分配
    private void optimizeOldGenerationAllocation(OldGenerationUsagePattern pattern) {
        if (pattern.getUsageRatio() > 0.8) {
            // 老年代使用率过高，建议增加老年代大小
            log.info("Suggesting to increase old generation size due to high usage");
        }
        
        if (pattern.getFullGCFrequency() > 0.5) {
            // Full GC频率过高，建议优化老年代配置
            log.info("Suggesting to optimize old generation configuration due to high Full GC frequency");
        }
        
        if (pattern.getFragmentationRatio() > 0.3) {
            // 内存碎片化严重，建议进行内存整理
            log.info("Suggesting to defragment memory due to high fragmentation ratio");
        }
    }
    
    // 优化元空间分配
    private void optimizeMetaspaceAllocation(MetaspaceUsagePattern pattern) {
        if (pattern.getUsageRatio() > 0.8) {
            // 元空间使用率过高，建议增加元空间大小
            log.info("Suggesting to increase metaspace size due to high usage");
        }
        
        if (pattern.getClassLoadingRate() > 50) {
            // 类加载速率过高，建议优化类加载策略
            log.info("Suggesting to optimize class loading strategy due to high class loading rate");
        }
    }
    
    // 执行堆内存清理
    public void performHeapMemoryCleanup() {
        log.info("Performing heap memory cleanup");
        
        try {
            // 清理新生代
            youngGenManager.performCleanup();
            
            // 清理老年代
            oldGenManager.performCleanup();
            
            // 清理元空间
            metaspaceManager.performCleanup();
            
            meterRegistry.counter("heap.cleanup.success").increment();
            
        } catch (Exception e) {
            log.error("Error performing heap memory cleanup", e);
            meterRegistry.counter("heap.cleanup.error").increment();
        }
    }
    
    // 更新堆内存指标
    private void updateHeapMemoryMetrics(HeapMemoryInfo heapInfo) {
        // 更新堆内存指标
        meterRegistry.gauge("heap.used", heapInfo.getUsed()).register();
        meterRegistry.gauge("heap.max", heapInfo.getMax()).register();
        meterRegistry.gauge("heap.committed", heapInfo.getCommitted()).register();
        meterRegistry.gauge("heap.usage_ratio", 
                (double) heapInfo.getUsed() / heapInfo.getMax()).register();
        
        // 更新新生代指标
        YoungGenerationInfo youngInfo = heapInfo.getYoungGenerationInfo();
        meterRegistry.gauge("heap.young.eden.used", youngInfo.getEdenUsed()).register();
        meterRegistry.gauge("heap.young.eden.max", youngInfo.getEdenMax()).register();
        meterRegistry.gauge("heap.young.survivor.used", youngInfo.getSurvivorUsed()).register();
        meterRegistry.gauge("heap.young.survivor.max", youngInfo.getSurvivorMax()).register();
        
        // 更新老年代指标
        OldGenerationInfo oldInfo = heapInfo.getOldGenerationInfo();
        meterRegistry.gauge("heap.old.used", oldInfo.getUsed()).register();
        meterRegistry.gauge("heap.old.max", oldInfo.getMax()).register();
        
        // 更新元空间指标
        MetaspaceInfo metaspaceInfo = heapInfo.getMetaspaceInfo();
        meterRegistry.gauge("heap.metaspace.used", metaspaceInfo.getUsed()).register();
        meterRegistry.gauge("heap.metaspace.max", metaspaceInfo.getMax()).register();
    }
}

// 新生代管理器
@Component
@Slf4j
public class YoungGenerationManager {
    
    private final MeterRegistry meterRegistry;
    
    public YoungGenerationManager(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }
    
    // 获取新生代信息
    public YoungGenerationInfo getYoungGenerationInfo() {
        YoungGenerationInfo info = new YoungGenerationInfo();
        
        try {
            // 获取内存池信息
            List<MemoryPoolMXBean> memoryPools = ManagementFactory.getMemoryPoolMXBeans();
            
            for (MemoryPoolMXBean pool : memoryPools) {
                String poolName = pool.getName();
                MemoryUsage usage = pool.getUsage();
                
                if (poolName.contains("Eden")) {
                    info.setEdenUsed(usage.getUsed());
                    info.setEdenMax(usage.getMax());
                    info.setEdenCommitted(usage.getCommitted());
                } else if (poolName.contains("Survivor")) {
                    info.setSurvivorUsed(usage.getUsed());
                    info.setSurvivorMax(usage.getMax());
                    info.setSurvivorCommitted(usage.getCommitted());
                }
            }
            
        } catch (Exception e) {
            log.error("Error getting young generation info", e);
        }
        
        return info;
    }
    
    // 执行新生代清理
    public void performCleanup() {
        log.info("Performing young generation cleanup");
        
        try {
            // 这里可以实现新生代特定的清理逻辑
            // 比如清理短期对象、优化对象分配等
            
            meterRegistry.counter("young_generation.cleanup.success").increment();
            
        } catch (Exception e) {
            log.error("Error performing young generation cleanup", e);
            meterRegistry.counter("young_generation.cleanup.error").increment();
        }
    }
}

// 智能栈内存管理器
@Component
@Slf4j
public class IntelligentStackMemoryManager {
    
    private final ThreadManager threadManager;
    private final MeterRegistry meterRegistry;
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(5);
    
    public IntelligentStackMemoryManager(ThreadManager threadManager,
                                        MeterRegistry meterRegistry) {
        this.threadManager = threadManager;
        this.meterRegistry = meterRegistry;
        
        // 启动栈内存管理
        startStackMemoryManagement();
    }
    
    // 启动栈内存管理
    private void startStackMemoryManagement() {
        // 定期监控栈内存使用
        scheduler.scheduleAtFixedRate(() -> {
            try {
                monitorStackMemoryUsage();
            } catch (Exception e) {
                log.error("Error monitoring stack memory usage", e);
            }
        }, 0, 5, TimeUnit.SECONDS);
        
        // 定期优化栈内存分配
        scheduler.scheduleAtFixedRate(() -> {
            try {
                optimizeStackMemoryAllocation();
            } catch (Exception e) {
                log.error("Error optimizing stack memory allocation", e);
            }
        }, 0, 30, TimeUnit.SECONDS);
    }
    
    // 监控栈内存使用
    public void monitorStackMemoryUsage() {
        try {
            // 获取所有线程信息
            ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
            long[] threadIds = threadBean.getAllThreadIds();
            
            StackMemoryInfo stackInfo = new StackMemoryInfo();
            List<ThreadStackInfo> threadStacks = new ArrayList<>();
            
            for (long threadId : threadIds) {
                ThreadInfo threadInfo = threadBean.getThreadInfo(threadId);
                if (threadInfo != null) {
                    ThreadStackInfo stack = analyzeThreadStack(threadInfo);
                    threadStacks.add(stack);
                }
            }
            
            stackInfo.setThreadStacks(threadStacks);
            
            // 分析栈内存使用模式
            StackUsagePattern pattern = analyzeStackUsagePattern(stackInfo);
            
            // 检测栈内存异常
            detectStackMemoryAnomalies(stackInfo, pattern);
            
            // 更新指标
            updateStackMemoryMetrics(stackInfo);
            
        } catch (Exception e) {
            log.error("Error monitoring stack memory usage", e);
            meterRegistry.counter("stack.monitoring.error").increment();
        }
    }
    
    // 分析线程栈
    private ThreadStackInfo analyzeThreadStack(ThreadInfo threadInfo) {
        ThreadStackInfo stack = new ThreadStackInfo();
        
        stack.setThreadId(threadInfo.getThreadId());
        stack.setThreadName(threadInfo.getThreadName());
        stack.setThreadState(threadInfo.getThreadState());
        
        // 分析栈深度
        StackTraceElement[] stackTrace = threadInfo.getStackTrace();
        stack.setStackDepth(stackTrace.length);
        
        // 分析栈帧大小
        long stackSize = calculateStackSize(stackTrace);
        stack.setStackSize(stackSize);
        
        // 分析本地变量数量
        int localVariableCount = estimateLocalVariableCount(stackTrace);
        stack.setLocalVariableCount(localVariableCount);
        
        return stack;
    }
    
    // 计算栈大小
    private long calculateStackSize(StackTraceElement[] stackTrace) {
        // 估算栈大小（每个栈帧大约1KB）
        return stackTrace.length * 1024L;
    }
    
    // 估算本地变量数量
    private int estimateLocalVariableCount(StackTraceElement[] stackTrace) {
        // 根据栈深度估算本地变量数量
        return stackTrace.length * 5; // 假设每个方法平均5个本地变量
    }
    
    // 分析栈内存使用模式
    private StackUsagePattern analyzeStackUsagePattern(StackMemoryInfo stackInfo) {
        StackUsagePattern pattern = new StackUsagePattern();
        
        List<ThreadStackInfo> threadStacks = stackInfo.getThreadStacks();
        
        // 计算平均栈深度
        double avgStackDepth = threadStacks.stream()
                .mapToInt(ThreadStackInfo::getStackDepth)
                .average()
                .orElse(0.0);
        pattern.setAverageStackDepth(avgStackDepth);
        
        // 计算最大栈深度
        int maxStackDepth = threadStacks.stream()
                .mapToInt(ThreadStackInfo::getStackDepth)
                .max()
                .orElse(0);
        pattern.setMaxStackDepth(maxStackDepth);
        
        // 计算总栈大小
        long totalStackSize = threadStacks.stream()
                .mapToLong(ThreadStackInfo::getStackSize)
                .sum();
        pattern.setTotalStackSize(totalStackSize);
        
        // 计算平均本地变量数量
        double avgLocalVariableCount = threadStacks.stream()
                .mapToInt(ThreadStackInfo::getLocalVariableCount)
                .average()
                .orElse(0.0);
        pattern.setAverageLocalVariableCount(avgLocalVariableCount);
        
        return pattern;
    }
    
    // 检测栈内存异常
    private void detectStackMemoryAnomalies(StackMemoryInfo stackInfo, StackUsagePattern pattern) {
        // 检测栈深度过深
        if (pattern.getMaxStackDepth() > 100) {
            log.warn("Stack depth is too deep: {}", pattern.getMaxStackDepth());
            triggerStackMemoryAlert(AlertSeverity.WARNING, "Stack depth too deep");
        }
        
        // 检测栈大小过大
        if (pattern.getTotalStackSize() > 100 * 1024 * 1024) { // 100MB
            log.warn("Total stack size is too large: {} MB", 
                    pattern.getTotalStackSize() / (1024 * 1024));
            triggerStackMemoryAlert(AlertSeverity.WARNING, "Total stack size too large");
        }
        
        // 检测本地变量过多
        if (pattern.getAverageLocalVariableCount() > 100) {
            log.warn("Average local variable count is too high: {}", 
                    pattern.getAverageLocalVariableCount());
            triggerStackMemoryAlert(AlertSeverity.WARNING, "Too many local variables");
        }
        
        // 检测线程数量过多
        if (stackInfo.getThreadStacks().size() > 1000) {
            log.warn("Thread count is too high: {}", stackInfo.getThreadStacks().size());
            triggerStackMemoryAlert(AlertSeverity.WARNING, "Too many threads");
        }
    }
    
    // 触发栈内存告警
    private void triggerStackMemoryAlert(AlertSeverity severity, String message) {
        try {
            Alert alert = Alert.builder()
                    .title("Stack Memory Alert")
                    .description(message)
                    .severity(severity)
                    .timestamp(System.currentTimeMillis())
                    .build();
            
            log.info("Stack memory alert triggered: {}", alert);
            
            meterRegistry.counter("stack.alert.triggered")
                    .tag("severity", severity.name())
                    .increment();
            
        } catch (Exception e) {
            log.error("Error triggering stack memory alert", e);
        }
    }
    
    // 优化栈内存分配
    public void optimizeStackMemoryAllocation() {
        log.info("Optimizing stack memory allocation");
        
        try {
            // 获取当前栈内存信息
            StackMemoryInfo stackInfo = new StackMemoryInfo();
            // 这里可以获取当前栈内存信息
            
            // 优化线程栈大小
            optimizeThreadStackSize(stackInfo);
            
            // 优化本地变量使用
            optimizeLocalVariableUsage(stackInfo);
            
            // 优化方法调用深度
            optimizeMethodCallDepth(stackInfo);
            
            meterRegistry.counter("stack.optimization.success").increment();
            
        } catch (Exception e) {
            log.error("Error optimizing stack memory allocation", e);
            meterRegistry.counter("stack.optimization.error").increment();
        }
    }
    
    // 优化线程栈大小
    private void optimizeThreadStackSize(StackMemoryInfo stackInfo) {
        // 这里可以实现线程栈大小优化逻辑
        log.info("Optimizing thread stack size");
    }
    
    // 优化本地变量使用
    private void optimizeLocalVariableUsage(StackMemoryInfo stackInfo) {
        // 这里可以实现本地变量使用优化逻辑
        log.info("Optimizing local variable usage");
    }
    
    // 优化方法调用深度
    private void optimizeMethodCallDepth(StackMemoryInfo stackInfo) {
        // 这里可以实现方法调用深度优化逻辑
        log.info("Optimizing method call depth");
    }
    
    // 更新栈内存指标
    private void updateStackMemoryMetrics(StackMemoryInfo stackInfo) {
        List<ThreadStackInfo> threadStacks = stackInfo.getThreadStacks();
        
        // 更新线程数量指标
        meterRegistry.gauge("stack.thread_count", threadStacks.size()).register();
        
        // 更新栈深度指标
        double avgStackDepth = threadStacks.stream()
                .mapToInt(ThreadStackInfo::getStackDepth)
                .average()
                .orElse(0.0);
        meterRegistry.gauge("stack.average_depth", avgStackDepth).register();
        
        int maxStackDepth = threadStacks.stream()
                .mapToInt(ThreadStackInfo::getStackDepth)
                .max()
                .orElse(0);
        meterRegistry.gauge("stack.max_depth", maxStackDepth).register();
        
        // 更新栈大小指标
        long totalStackSize = threadStacks.stream()
                .mapToLong(ThreadStackInfo::getStackSize)
                .sum();
        meterRegistry.gauge("stack.total_size", totalStackSize).register();
        
        // 更新本地变量指标
        double avgLocalVariableCount = threadStacks.stream()
                .mapToInt(ThreadStackInfo::getLocalVariableCount)
                .average()
                .orElse(0.0);
        meterRegistry.gauge("stack.average_local_variables", avgLocalVariableCount).register();
    }
}

// 智能方法区管理器
@Component
@Slf4j
public class IntelligentMethodAreaManager {
    
    private final ClassLoaderManager classLoaderManager;
    private final ConstantPoolManager constantPoolManager;
    private final MeterRegistry meterRegistry;
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(5);
    
    public IntelligentMethodAreaManager(ClassLoaderManager classLoaderManager,
                                      ConstantPoolManager constantPoolManager,
                                      MeterRegistry meterRegistry) {
        this.classLoaderManager = classLoaderManager;
        this.constantPoolManager = constantPoolManager;
        this.meterRegistry = meterRegistry;
        
        // 启动方法区管理
        startMethodAreaManagement();
    }
    
    // 启动方法区管理
    private void startMethodAreaManagement() {
        // 定期监控方法区使用
        scheduler.scheduleAtFixedRate(() -> {
            try {
                monitorMethodAreaUsage();
            } catch (Exception e) {
                log.error("Error monitoring method area usage", e);
            }
        }, 0, 10, TimeUnit.SECONDS);
        
        // 定期优化方法区分配
        scheduler.scheduleAtFixedRate(() -> {
            try {
                optimizeMethodAreaAllocation();
            } catch (Exception e) {
                log.error("Error optimizing method area allocation", e);
            }
        }, 0, 60, TimeUnit.SECONDS);
    }
    
    // 监控方法区使用
    public void monitorMethodAreaUsage() {
        try {
            // 获取方法区信息
            MethodAreaInfo methodAreaInfo = getMethodAreaInfo();
            
            // 分析方法区使用模式
            MethodAreaUsagePattern pattern = analyzeMethodAreaUsagePattern(methodAreaInfo);
            
            // 检测方法区异常
            detectMethodAreaAnomalies(methodAreaInfo, pattern);
            
            // 更新指标
            updateMethodAreaMetrics(methodAreaInfo);
            
        } catch (Exception e) {
            log.error("Error monitoring method area usage", e);
            meterRegistry.counter("method_area.monitoring.error").increment();
        }
    }
    
    // 获取方法区信息
    private MethodAreaInfo getMethodAreaInfo() {
        MethodAreaInfo info = new MethodAreaInfo();
        
        try {
            // 获取类加载器信息
            ClassLoaderInfo classLoaderInfo = classLoaderManager.getClassLoaderInfo();
            info.setClassLoaderInfo(classLoaderInfo);
            
            // 获取常量池信息
            ConstantPoolInfo constantPoolInfo = constantPoolManager.getConstantPoolInfo();
            info.setConstantPoolInfo(constantPoolInfo);
            
            // 获取静态变量信息
            StaticVariableInfo staticVariableInfo = getStaticVariableInfo();
            info.setStaticVariableInfo(staticVariableInfo);
            
            // 获取方法信息
            MethodInfo methodInfo = getMethodInfo();
            info.setMethodInfo(methodInfo);
            
        } catch (Exception e) {
            log.error("Error getting method area info", e);
        }
        
        return info;
    }
    
    // 获取静态变量信息
    private StaticVariableInfo getStaticVariableInfo() {
        StaticVariableInfo info = new StaticVariableInfo();
        
        try {
            // 这里可以获取静态变量信息
            info.setCount(1000); // 模拟1000个静态变量
            info.setTotalSize(1024 * 1024); // 模拟1MB
            
        } catch (Exception e) {
            log.error("Error getting static variable info", e);
        }
        
        return info;
    }
    
    // 获取方法信息
    private MethodInfo getMethodInfo() {
        MethodInfo info = new MethodInfo();
        
        try {
            // 这里可以获取方法信息
            info.setCount(5000); // 模拟5000个方法
            info.setTotalSize(5 * 1024 * 1024); // 模拟5MB
            
        } catch (Exception e) {
            log.error("Error getting method info", e);
        }
        
        return info;
    }
    
    // 分析方法区使用模式
    private MethodAreaUsagePattern analyzeMethodAreaUsagePattern(MethodAreaInfo methodAreaInfo) {
        MethodAreaUsagePattern pattern = new MethodAreaUsagePattern();
        
        // 分析类加载模式
        ClassLoaderInfo classLoaderInfo = methodAreaInfo.getClassLoaderInfo();
        pattern.setClassCount(classLoaderInfo.getLoadedClassCount());
        pattern.setClassLoadingRate(classLoaderInfo.getClassLoadingRate());
        
        // 分析常量池模式
        ConstantPoolInfo constantPoolInfo = methodAreaInfo.getConstantPoolInfo();
        pattern.setConstantCount(constantPoolInfo.getConstantCount());
        pattern.setConstantPoolSize(constantPoolInfo.getTotalSize());
        
        // 分析静态变量模式
        StaticVariableInfo staticVariableInfo = methodAreaInfo.getStaticVariableInfo();
        pattern.setStaticVariableCount(staticVariableInfo.getCount());
        pattern.setStaticVariableSize(staticVariableInfo.getTotalSize());
        
        // 分析方法模式
        MethodInfo methodInfo = methodAreaInfo.getMethodInfo();
        pattern.setMethodCount(methodInfo.getCount());
        pattern.setMethodSize(methodInfo.getTotalSize());
        
        return pattern;
    }
    
    // 检测方法区异常
    private void detectMethodAreaAnomalies(MethodAreaInfo methodAreaInfo, MethodAreaUsagePattern pattern) {
        // 检测类数量过多
        if (pattern.getClassCount() > 10000) {
            log.warn("Class count is too high: {}", pattern.getClassCount());
            triggerMethodAreaAlert(AlertSeverity.WARNING, "Too many loaded classes");
        }
        
        // 检测类加载速率过高
        if (pattern.getClassLoadingRate() > 100) {
            log.warn("Class loading rate is too high: {} per second", pattern.getClassLoadingRate());
            triggerMethodAreaAlert(AlertSeverity.WARNING, "High class loading rate");
        }
        
        // 检测常量池过大
        if (pattern.getConstantPoolSize() > 10 * 1024 * 1024) { // 10MB
            log.warn("Constant pool size is too large: {} MB", 
                    pattern.getConstantPoolSize() / (1024 * 1024));
            triggerMethodAreaAlert(AlertSeverity.WARNING, "Large constant pool");
        }
        
        // 检测静态变量过多
        if (pattern.getStaticVariableCount() > 5000) {
            log.warn("Static variable count is too high: {}", pattern.getStaticVariableCount());
            triggerMethodAreaAlert(AlertSeverity.WARNING, "Too many static variables");
        }
        
        // 检测方法数量过多
        if (pattern.getMethodCount() > 20000) {
            log.warn("Method count is too high: {}", pattern.getMethodCount());
            triggerMethodAreaAlert(AlertSeverity.WARNING, "Too many methods");
        }
    }
    
    // 触发方法区告警
    private void triggerMethodAreaAlert(AlertSeverity severity, String message) {
        try {
            Alert alert = Alert.builder()
                    .title("Method Area Alert")
                    .description(message)
                    .severity(severity)
                    .timestamp(System.currentTimeMillis())
                    .build();
            
            log.info("Method area alert triggered: {}", alert);
            
            meterRegistry.counter("method_area.alert.triggered")
                    .tag("severity", severity.name())
                    .increment();
            
        } catch (Exception e) {
            log.error("Error triggering method area alert", e);
        }
    }
    
    // 优化方法区分配
    public void optimizeMethodAreaAllocation() {
        log.info("Optimizing method area allocation");
        
        try {
            // 获取当前方法区信息
            MethodAreaInfo methodAreaInfo = getMethodAreaInfo();
            MethodAreaUsagePattern pattern = analyzeMethodAreaUsagePattern(methodAreaInfo);
            
            // 优化类加载策略
            optimizeClassLoadingStrategy(pattern);
            
            // 优化常量池使用
            optimizeConstantPoolUsage(pattern);
            
            // 优化静态变量使用
            optimizeStaticVariableUsage(pattern);
            
            // 优化方法使用
            optimizeMethodUsage(pattern);
            
            meterRegistry.counter("method_area.optimization.success").increment();
            
        } catch (Exception e) {
            log.error("Error optimizing method area allocation", e);
            meterRegistry.counter("method_area.optimization.error").increment();
        }
    }
    
    // 优化类加载策略
    private void optimizeClassLoadingStrategy(MethodAreaUsagePattern pattern) {
        if (pattern.getClassLoadingRate() > 50) {
            log.info("Suggesting to optimize class loading strategy due to high loading rate");
        }
        
        if (pattern.getClassCount() > 5000) {
            log.info("Suggesting to unload unused classes due to high class count");
        }
    }
    
    // 优化常量池使用
    private void optimizeConstantPoolUsage(MethodAreaUsagePattern pattern) {
        if (pattern.getConstantPoolSize() > 5 * 1024 * 1024) { // 5MB
            log.info("Suggesting to optimize constant pool usage due to large size");
        }
    }
    
    // 优化静态变量使用
    private void optimizeStaticVariableUsage(MethodAreaUsagePattern pattern) {
        if (pattern.getStaticVariableCount() > 2000) {
            log.info("Suggesting to optimize static variable usage due to high count");
        }
    }
    
    // 优化方法使用
    private void optimizeMethodUsage(MethodAreaUsagePattern pattern) {
        if (pattern.getMethodCount() > 10000) {
            log.info("Suggesting to optimize method usage due to high count");
        }
    }
    
    // 更新方法区指标
    private void updateMethodAreaMetrics(MethodAreaInfo methodAreaInfo) {
        // 更新类加载器指标
        ClassLoaderInfo classLoaderInfo = methodAreaInfo.getClassLoaderInfo();
        meterRegistry.gauge("method_area.class_count", classLoaderInfo.getLoadedClassCount()).register();
        meterRegistry.gauge("method_area.class_loading_rate", classLoaderInfo.getClassLoadingRate()).register();
        
        // 更新常量池指标
        ConstantPoolInfo constantPoolInfo = methodAreaInfo.getConstantPoolInfo();
        meterRegistry.gauge("method_area.constant_count", constantPoolInfo.getConstantCount()).register();
        meterRegistry.gauge("method_area.constant_pool_size", constantPoolInfo.getTotalSize()).register();
        
        // 更新静态变量指标
        StaticVariableInfo staticVariableInfo = methodAreaInfo.getStaticVariableInfo();
        meterRegistry.gauge("method_area.static_variable_count", staticVariableInfo.getCount()).register();
        meterRegistry.gauge("method_area.static_variable_size", staticVariableInfo.getTotalSize()).register();
        
        // 更新方法指标
        MethodInfo methodInfo = methodAreaInfo.getMethodInfo();
        meterRegistry.gauge("method_area.method_count", methodInfo.getCount()).register();
        meterRegistry.gauge("method_area.method_size", methodInfo.getTotalSize()).register();
    }
}

// 智能直接内存管理器
@Component
@Slf4j
public class IntelligentDirectMemoryManager {
    
    private final DirectByteBufferManager byteBufferManager;
    private final MemoryMappedFileManager mappedFileManager;
    private final MeterRegistry meterRegistry;
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(5);
    
    public IntelligentDirectMemoryManager(DirectByteBufferManager byteBufferManager,
                                         MemoryMappedFileManager mappedFileManager,
                                         MeterRegistry meterRegistry) {
        this.byteBufferManager = byteBufferManager;
        this.mappedFileManager = mappedFileManager;
        this.meterRegistry = meterRegistry;
        
        // 启动直接内存管理
        startDirectMemoryManagement();
    }
    
    // 启动直接内存管理
    private void startDirectMemoryManagement() {
        // 定期监控直接内存使用
        scheduler.scheduleAtFixedRate(() -> {
            try {
                monitorDirectMemoryUsage();
            } catch (Exception e) {
                log.error("Error monitoring direct memory usage", e);
            }
        }, 0, 5, TimeUnit.SECONDS);
        
        // 定期优化直接内存分配
        scheduler.scheduleAtFixedRate(() -> {
            try {
                optimizeDirectMemoryAllocation();
            } catch (Exception e) {
                log.error("Error optimizing direct memory allocation", e);
            }
        }, 0, 30, TimeUnit.SECONDS);
    }
    
    // 监控直接内存使用
    public void monitorDirectMemoryUsage() {
        try {
            // 获取直接内存信息
            DirectMemoryInfo directMemoryInfo = getDirectMemoryInfo();
            
            // 分析直接内存使用模式
            DirectMemoryUsagePattern pattern = analyzeDirectMemoryUsagePattern(directMemoryInfo);
            
            // 检测直接内存异常
            detectDirectMemoryAnomalies(directMemoryInfo, pattern);
            
            // 更新指标
            updateDirectMemoryMetrics(directMemoryInfo);
            
        } catch (Exception e) {
            log.error("Error monitoring direct memory usage", e);
            meterRegistry.counter("direct_memory.monitoring.error").increment();
        }
    }
    
    // 获取直接内存信息
    private DirectMemoryInfo getDirectMemoryInfo() {
        DirectMemoryInfo info = new DirectMemoryInfo();
        
        try {
            // 获取直接内存使用情况
            long directMemoryUsed = getDirectMemoryUsed();
            long directMemoryMax = getDirectMemoryMax();
            
            info.setUsed(directMemoryUsed);
            info.setMax(directMemoryMax);
            info.setCommitted(directMemoryUsed);
            
            // 获取DirectByteBuffer信息
            DirectByteBufferInfo byteBufferInfo = byteBufferManager.getDirectByteBufferInfo();
            info.setDirectByteBufferInfo(byteBufferInfo);
            
            // 获取内存映射文件信息
            MemoryMappedFileInfo mappedFileInfo = mappedFileManager.getMemoryMappedFileInfo();
            info.setMemoryMappedFileInfo(mappedFileInfo);
            
        } catch (Exception e) {
            log.error("Error getting direct memory info", e);
        }
        
        return info;
    }
    
    // 获取直接内存使用量
    private long getDirectMemoryUsed() {
        try {
            // 这里可以通过JVM参数或工具获取直接内存使用量
            return 100 * 1024 * 1024; // 模拟100MB
        } catch (Exception e) {
            log.error("Error getting direct memory used", e);
            return 0;
        }
    }
    
    // 获取直接内存最大值
    private long getDirectMemoryMax() {
        try {
            // 这里可以通过JVM参数获取直接内存最大值
            return 1024 * 1024 * 1024; // 模拟1GB
        } catch (Exception e) {
            log.error("Error getting direct memory max", e);
            return 0;
        }
    }
    
    // 分析直接内存使用模式
    private DirectMemoryUsagePattern analyzeDirectMemoryUsagePattern(DirectMemoryInfo directMemoryInfo) {
        DirectMemoryUsagePattern pattern = new DirectMemoryUsagePattern();
        
        // 计算直接内存使用率
        double usageRatio = (double) directMemoryInfo.getUsed() / directMemoryInfo.getMax();
        pattern.setUsageRatio(usageRatio);
        
        // 分析DirectByteBuffer使用模式
        DirectByteBufferInfo byteBufferInfo = directMemoryInfo.getDirectByteBufferInfo();
        pattern.setDirectByteBufferCount(byteBufferInfo.getCount());
        pattern.setDirectByteBufferSize(byteBufferInfo.getTotalSize());
        
        // 分析内存映射文件使用模式
        MemoryMappedFileInfo mappedFileInfo = directMemoryInfo.getMemoryMappedFileInfo();
        pattern.setMappedFileCount(mappedFileInfo.getCount());
        pattern.setMappedFileSize(mappedFileInfo.getTotalSize());
        
        // 计算直接内存分配速率
        double allocationRate = calculateDirectMemoryAllocationRate(directMemoryInfo);
        pattern.setAllocationRate(allocationRate);
        
        // 计算直接内存释放速率
        double deallocationRate = calculateDirectMemoryDeallocationRate(directMemoryInfo);
        pattern.setDeallocationRate(deallocationRate);
        
        return pattern;
    }
    
    // 计算直接内存分配速率
    private double calculateDirectMemoryAllocationRate(DirectMemoryInfo directMemoryInfo) {
        // 这里可以根据历史数据计算直接内存分配速率
        return 10.0; // 模拟10MB/s
    }
    
    // 计算直接内存释放速率
    private double calculateDirectMemoryDeallocationRate(DirectMemoryInfo directMemoryInfo) {
        // 这里可以根据历史数据计算直接内存释放速率
        return 8.0; // 模拟8MB/s
    }
    
    // 检测直接内存异常
    private void detectDirectMemoryAnomalies(DirectMemoryInfo directMemoryInfo, DirectMemoryUsagePattern pattern) {
        // 检测直接内存使用率过高
        if (pattern.getUsageRatio() > 0.9) {
            log.warn("Direct memory usage is high: {}%", pattern.getUsageRatio() * 100);
            triggerDirectMemoryAlert(AlertSeverity.CRITICAL, "High direct memory usage");
        } else if (pattern.getUsageRatio() > 0.8) {
            log.warn("Direct memory usage is moderate: {}%", pattern.getUsageRatio() * 100);
            triggerDirectMemoryAlert(AlertSeverity.WARNING, "Moderate direct memory usage");
        }
        
        // 检测DirectByteBuffer数量过多
        if (pattern.getDirectByteBufferCount() > 1000) {
            log.warn("DirectByteBuffer count is too high: {}", pattern.getDirectByteBufferCount());
            triggerDirectMemoryAlert(AlertSeverity.WARNING, "Too many DirectByteBuffers");
        }
        
        // 检测内存映射文件过多
        if (pattern.getMappedFileCount() > 100) {
            log.warn("Memory mapped file count is too high: {}", pattern.getMappedFileCount());
            triggerDirectMemoryAlert(AlertSeverity.WARNING, "Too many memory mapped files");
        }
        
        // 检测直接内存分配速率过高
        if (pattern.getAllocationRate() > 100) { // 100MB/s
            log.warn("Direct memory allocation rate is too high: {} MB/s", pattern.getAllocationRate());
            triggerDirectMemoryAlert(AlertSeverity.WARNING, "High direct memory allocation rate");
        }
    }
    
    // 触发直接内存告警
    private void triggerDirectMemoryAlert(AlertSeverity severity, String message) {
        try {
            Alert alert = Alert.builder()
                    .title("Direct Memory Alert")
                    .description(message)
                    .severity(severity)
                    .timestamp(System.currentTimeMillis())
                    .build();
            
            log.info("Direct memory alert triggered: {}", alert);
            
            meterRegistry.counter("direct_memory.alert.triggered")
                    .tag("severity", severity.name())
                    .increment();
            
        } catch (Exception e) {
            log.error("Error triggering direct memory alert", e);
        }
    }
    
    // 优化直接内存分配
    public void optimizeDirectMemoryAllocation() {
        log.info("Optimizing direct memory allocation");
        
        try {
            // 获取当前直接内存信息
            DirectMemoryInfo directMemoryInfo = getDirectMemoryInfo();
            DirectMemoryUsagePattern pattern = analyzeDirectMemoryUsagePattern(directMemoryInfo);
            
            // 优化DirectByteBuffer使用
            optimizeDirectByteBufferUsage(pattern);
            
            // 优化内存映射文件使用
            optimizeMemoryMappedFileUsage(pattern);
            
            // 优化直接内存分配策略
            optimizeDirectMemoryAllocationStrategy(pattern);
            
            meterRegistry.counter("direct_memory.optimization.success").increment();
            
        } catch (Exception e) {
            log.error("Error optimizing direct memory allocation", e);
            meterRegistry.counter("direct_memory.optimization.error").increment();
        }
    }
    
    // 优化DirectByteBuffer使用
    private void optimizeDirectByteBufferUsage(DirectMemoryUsagePattern pattern) {
        if (pattern.getDirectByteBufferCount() > 500) {
            log.info("Suggesting to optimize DirectByteBuffer usage due to high count");
        }
        
        if (pattern.getDirectByteBufferSize() > 500 * 1024 * 1024) { // 500MB
            log.info("Suggesting to optimize DirectByteBuffer size due to large total size");
        }
    }
    
    // 优化内存映射文件使用
    private void optimizeMemoryMappedFileUsage(DirectMemoryUsagePattern pattern) {
        if (pattern.getMappedFileCount() > 50) {
            log.info("Suggesting to optimize memory mapped file usage due to high count");
        }
        
        if (pattern.getMappedFileSize() > 200 * 1024 * 1024) { // 200MB
            log.info("Suggesting to optimize memory mapped file size due to large total size");
        }
    }
    
    // 优化直接内存分配策略
    private void optimizeDirectMemoryAllocationStrategy(DirectMemoryUsagePattern pattern) {
        if (pattern.getAllocationRate() > 50) { // 50MB/s
            log.info("Suggesting to optimize direct memory allocation strategy due to high allocation rate");
        }
        
        if (pattern.getDeallocationRate() < pattern.getAllocationRate() * 0.8) {
            log.info("Suggesting to improve direct memory deallocation due to low deallocation rate");
        }
    }
    
    // 更新直接内存指标
    private void updateDirectMemoryMetrics(DirectMemoryInfo directMemoryInfo) {
        // 更新直接内存指标
        meterRegistry.gauge("direct_memory.used", directMemoryInfo.getUsed()).register();
        meterRegistry.gauge("direct_memory.max", directMemoryInfo.getMax()).register();
        meterRegistry.gauge("direct_memory.committed", directMemoryInfo.getCommitted()).register();
        meterRegistry.gauge("direct_memory.usage_ratio", 
                (double) directMemoryInfo.getUsed() / directMemoryInfo.getMax()).register();
        
        // 更新DirectByteBuffer指标
        DirectByteBufferInfo byteBufferInfo = directMemoryInfo.getDirectByteBufferInfo();
        meterRegistry.gauge("direct_memory.byte_buffer.count", byteBufferInfo.getCount()).register();
        meterRegistry.gauge("direct_memory.byte_buffer.size", byteBufferInfo.getTotalSize()).register();
        
        // 更新内存映射文件指标
        MemoryMappedFileInfo mappedFileInfo = directMemoryInfo.getMemoryMappedFileInfo();
        meterRegistry.gauge("direct_memory.mapped_file.count", mappedFileInfo.getCount()).register();
        meterRegistry.gauge("direct_memory.mapped_file.size", mappedFileInfo.getTotalSize()).register();
    }
}