第257集如何排查OOM？内存溢出架构实战：OOM诊断、内存分析与企业级故障处理设计

/**
 * Java堆内存溢出示例
 */
public class HeapOOMExample {

    /**
     * 模拟堆内存溢出
     */
    public void simulateHeapOOM() {
        List<byte[]> list = new ArrayList<>();

        try {
            while (true) {
                // 每次分配1MB内存
                byte[] data = new byte[1024 * 1024];
                list.add(data);

                // 模拟业务处理
                Thread.sleep(100);
            }
        } catch (OutOfMemoryError e) {
            System.err.println("堆内存溢出: " + e.getMessage());
            // 记录OOM信息
            logOOMInfo("Heap Space", e);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    /**
     * 记录OOM信息
     */
    private void logOOMInfo(String oomType, OutOfMemoryError e) {
        MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();

        System.err.println("OOM类型: " + oomType);
        System.err.println("堆内存使用: " + heapUsage.getUsed() + " / " + heapUsage.getMax());
        System.err.println("堆内存使用率: " + (heapUsage.getUsed() * 100.0 / heapUsage.getMax()) + "%");

        // 生成堆转储
        generateHeapDump();
    }

    /**
     * 生成堆转储
     */
    private void generateHeapDump() {
        try {
            String fileName = "heap_dump_" + System.currentTimeMillis() + ".hprof";
            HotSpotDiagnosticMXBean diagnosticBean = ManagementFactory.getPlatformMXBean(HotSpotDiagnosticMXBean.class);
            diagnosticBean.dumpHeap(fileName, true);
            System.err.println("堆转储已生成: " + fileName);
        } catch (Exception e) {
            System.err.println("生成堆转储失败: " + e.getMessage());
        }
    }
}

/**
 * 元空间内存溢出示例
 */
public class MetaspaceOOMExample {

    /**
     * 模拟元空间内存溢出
     */
    public void simulateMetaspaceOOM() {
        try {
            // 动态生成大量类
            for (int i = 0; i < 100000; i++) {
                generateDynamicClass("DynamicClass" + i);
            }
        } catch (OutOfMemoryError e) {
            System.err.println("元空间内存溢出: " + e.getMessage());
            logMetaspaceOOMInfo(e);
        }
    }

    /**
     * 动态生成类
     */
    private void generateDynamicClass(String className) {
        try {
            ClassPool pool = ClassPool.getDefault();
            CtClass ctClass = pool.makeClass(className);

            // 添加字段
            ctClass.addField(CtField.make("private String field" + System.currentTimeMillis() + ";", ctClass));

            // 添加方法
            ctClass.addMethod(CtMethod.make("public void method" + System.currentTimeMillis() + "() {}", ctClass));

            // 生成类
            ctClass.toClass();
        } catch (Exception e) {
            throw new RuntimeException("生成动态类失败", e);
        }
    }

    /**
     * 记录元空间OOM信息
     */
    private void logMetaspaceOOMInfo(OutOfMemoryError e) {
        MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
        MemoryUsage nonHeapUsage = memoryBean.getNonHeapMemoryUsage();

        System.err.println("元空间内存使用: " + nonHeapUsage.getUsed() + " / " + nonHeapUsage.getMax());
        System.err.println("元空间内存使用率: " + (nonHeapUsage.getUsed() * 100.0 / nonHeapUsage.getMax()) + "%");
    }
}

/**
 * 直接内存溢出示例
 */
public class DirectMemoryOOMExample {

    /**
     * 模拟直接内存溢出
     */
    public void simulateDirectMemoryOOM() {
        List<ByteBuffer> buffers = new ArrayList<>();

        try {
            while (true) {
                // 分配直接内存
                ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024); // 1MB
                buffers.add(buffer);

                // 模拟业务处理
                Thread.sleep(10);
            }
        } catch (OutOfMemoryError e) {
            System.err.println("直接内存溢出: " + e.getMessage());
            logDirectMemoryOOMInfo(e);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    /**
     * 记录直接内存OOM信息
     */
    private void logDirectMemoryOOMInfo(OutOfMemoryError e) {
        // 获取直接内存使用情况
        long directMemoryUsed = ((sun.misc.SharedSecrets.getJavaNioAccess()
                .getDirectBufferPool()).getMemoryUsed());

        System.err.println("直接内存使用: " + directMemoryUsed + " bytes");
        System.err.println("最大直接内存: " + VM.maxDirectMemory() + " bytes");
    }
}

/**
 * 内存分析工具集成
 */
@Component
public class MemoryAnalysisTool {

    @Autowired
    private MemoryMXBean memoryBean;

    /**
     * 内存使用情况分析
     */
    public MemoryAnalysisResult analyzeMemoryUsage() {
        MemoryAnalysisResult result = new MemoryAnalysisResult();

        // 堆内存分析
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        result.setHeapUsed(heapUsage.getUsed());
        result.setHeapMax(heapUsage.getMax());
        result.setHeapUsagePercent(heapUsage.getUsed() * 100.0 / heapUsage.getMax());

        // 非堆内存分析
        MemoryUsage nonHeapUsage = memoryBean.getNonHeapMemoryUsage();
        result.setNonHeapUsed(nonHeapUsage.getUsed());
        result.setNonHeapMax(nonHeapUsage.getMax());
        result.setNonHeapUsagePercent(nonHeapUsage.getUsed() * 100.0 / nonHeapUsage.getMax());

        // GC分析
        analyzeGC(result);

        // 类加载分析
        analyzeClassLoading(result);

        return result;
    }

    /**
     * GC分析
     */
    private void analyzeGC(MemoryAnalysisResult result) {
        List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans();

        long totalGcCount = 0;
        long totalGcTime = 0;

        for (GarbageCollectorMXBean gcBean : gcBeans) {
            totalGcCount += gcBean.getCollectionCount();
            totalGcTime += gcBean.getCollectionTime();
        }

        result.setTotalGcCount(totalGcCount);
        result.setTotalGcTime(totalGcTime);
        result.setAverageGcTime(totalGcCount > 0 ? totalGcTime / totalGcCount : 0);
    }

    /**
     * 类加载分析
     */
    private void analyzeClassLoading(MemoryAnalysisResult result) {
        ClassLoadingMXBean classBean = ManagementFactory.getClassLoadingMXBean();
        result.setLoadedClassCount(classBean.getLoadedClassCount());
        result.setTotalLoadedClassCount(classBean.getTotalLoadedClassCount());
        result.setUnloadedClassCount(classBean.getUnloadedClassCount());
    }
}

/**
 * 集合类内存泄漏示例
 */
public class CollectionMemoryLeakExample {

    private static final List<Object> staticList = new ArrayList<>();
    private static final Map<String, Object> staticMap = new HashMap<>();

    /**
     * 静态集合导致的内存泄漏
     */
    public void staticCollectionLeak() {
        // 向静态集合添加对象，但从不移除
        for (int i = 0; i < 10000; i++) {
            staticList.add(new LargeObject("data" + i));
            staticMap.put("key" + i, new LargeObject("data" + i));
        }
    }

    /**
     * 监听器未移除导致的内存泄漏
     */
    public void listenerLeak() {
        EventSource eventSource = new EventSource();

        for (int i = 0; i < 1000; i++) {
            EventListener listener = new EventListener() {
                @Override
                public void onEvent(Event event) {
                    // 处理事件
                }
            };

            // 添加监听器但忘记移除
            eventSource.addEventListener(listener);
        }
    }

    /**
     * 缓存未设置过期时间导致的内存泄漏
     */
    public void cacheLeak() {
        Map<String, Object> cache = new HashMap<>();

        // 不断向缓存添加数据，但从不清理
        for (int i = 0; i < 100000; i++) {
            cache.put("key" + i, new LargeObject("cached_data" + i));
        }
    }

    /**
     * 正确的集合使用方式
     */
    public void correctCollectionUsage() {
        // 使用WeakHashMap避免内存泄漏
        Map<String, Object> weakMap = new WeakHashMap<>();

        // 使用LinkedHashMap实现LRU缓存
        Map<String, Object> lruCache = Collections.synchronizedMap(
            new LinkedHashMap<String, Object>(16, 0.75f, true) {
                @Override
                protected boolean removeEldestEntry(Map.Entry<String, Object> eldest) {
                    return size() > 1000;
                }
            }
        );

        // 定期清理缓存
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        scheduler.scheduleAtFixedRate(() -> {
            lruCache.entrySet().removeIf(entry -> 
                System.currentTimeMillis() - (Long) entry.getValue() > 3600000); // 1小时过期
        }, 0, 5, TimeUnit.MINUTES);
    }
}

/**
 * 线程池内存泄漏示例
 */
public class ThreadPoolMemoryLeakExample {

    private ExecutorService executor;

    /**
     * 线程池未正确关闭导致的内存泄漏
     */
    public void threadPoolLeak() {
        // 创建线程池但忘记关闭
        executor = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 1000; i++) {
            executor.submit(() -> {
                // 长时间运行的任务
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
    }

    /**
     * 正确的线程池使用方式
     */
    public void correctThreadPoolUsage() {
        executor = Executors.newFixedThreadPool(10);

        try {
            for (int i = 0; i < 1000; i++) {
                executor.submit(() -> {
                    // 业务逻辑
                    return "result";
                });
            }
        } finally {
            // 正确关闭线程池
            executor.shutdown();
            try {
                if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                    executor.shutdownNow();
                }
            } catch (InterruptedException e) {
                executor.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }
    }
}

/**
 * 内存泄漏自动检测工具
 */
@Component
public class MemoryLeakDetector {

    @Autowired
    private MemoryMXBean memoryBean;

    private final Map<String, Long> memorySnapshots = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    /**
     * 启动内存泄漏检测
     */
    @PostConstruct
    public void startMemoryLeakDetection() {
        scheduler.scheduleAtFixedRate(this::detectMemoryLeak, 0, 5, TimeUnit.MINUTES);
    }

    /**
     * 检测内存泄漏
     */
    public void detectMemoryLeak() {
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        long currentMemory = heapUsage.getUsed();
        String timestamp = String.valueOf(System.currentTimeMillis());

        // 记录内存快照
        memorySnapshots.put(timestamp, currentMemory);

        // 分析内存增长趋势
        analyzeMemoryGrowthTrend();

        // 清理过期快照
        cleanupOldSnapshots();
    }

    /**
     * 分析内存增长趋势
     */
    private void analyzeMemoryGrowthTrend() {
        if (memorySnapshots.size() < 10) {
            return; // 需要足够的数据点
        }

        List<Long> memoryValues = new ArrayList<>(memorySnapshots.values());
        Collections.sort(memoryValues);

        // 计算内存增长趋势
        double growthRate = calculateGrowthRate(memoryValues);

        if (growthRate > 0.1) { // 内存增长超过10%
            log.warn("检测到内存泄漏，增长率为: {}%", growthRate * 100);

            // 生成内存分析报告
            generateMemoryAnalysisReport();

            // 发送告警
            sendMemoryLeakAlert(growthRate);
        }
    }

    /**
     * 计算内存增长率
     */
    private double calculateGrowthRate(List<Long> memoryValues) {
        if (memoryValues.size() < 2) {
            return 0;
        }

        long firstValue = memoryValues.get(0);
        long lastValue = memoryValues.get(memoryValues.size() - 1);

        return (double) (lastValue - firstValue) / firstValue;
    }

    /**
     * 生成内存分析报告
     */
    private void generateMemoryAnalysisReport() {
        MemoryAnalysisReport report = new MemoryAnalysisReport();

        // 收集内存使用信息
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        report.setHeapUsed(heapUsage.getUsed());
        report.setHeapMax(heapUsage.getMax());
        report.setTimestamp(System.currentTimeMillis());

        // 收集GC信息
        List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans();
        long totalGcCount = gcBeans.stream().mapToLong(GarbageCollectorMXBean::getCollectionCount).sum();
        long totalGcTime = gcBeans.stream().mapToLong(GarbageCollectorMXBean::getCollectionTime).sum();

        report.setTotalGcCount(totalGcCount);
        report.setTotalGcTime(totalGcTime);

        // 保存报告
        saveMemoryAnalysisReport(report);
    }
}

/**
 * 堆转储分析工具
 */
@Component
public class HeapDumpAnalyzer {

    /**
     * 分析堆转储文件
     */
    public HeapAnalysisResult analyzeHeapDump(String heapDumpPath) {
        HeapAnalysisResult result = new HeapAnalysisResult();

        try {
            // 使用Eclipse MAT API分析堆转储
            IStructuredModel model = StructuredModelManager.getModelManager()
                    .getModelForRead(new File(heapDumpPath));

            if (model instanceof IMemorySnapshot) {
                IMemorySnapshot snapshot = (IMemorySnapshot) model;

                // 分析大对象
                analyzeLargeObjects(snapshot, result);

                // 分析重复对象
                analyzeDuplicateObjects(snapshot, result);

                // 分析对象引用
                analyzeObjectReferences(snapshot, result);

                // 分析内存泄漏
                analyzeMemoryLeaks(snapshot, result);
            }

        } catch (Exception e) {
            log.error("分析堆转储失败", e);
        }

        return result;
    }

    /**
     * 分析大对象
     */
    private void analyzeLargeObjects(IMemorySnapshot snapshot, HeapAnalysisResult result) {
        List<LargeObjectInfo> largeObjects = new ArrayList<>();

        // 获取所有对象
        IObjectList objects = snapshot.getObjects();

        for (IObject object : objects) {
            if (object.getUsedHeapSize() > 1024 * 1024) { // 大于1MB的对象
                LargeObjectInfo info = new LargeObjectInfo();
                info.setClassName(object.getClazz().getName());
                info.setSize(object.getUsedHeapSize());
                info.setCount(1);
                largeObjects.add(info);
            }
        }

        result.setLargeObjects(largeObjects);
    }

    /**
     * 分析重复对象
     */
    private void analyzeDuplicateObjects(IMemorySnapshot snapshot, HeapAnalysisResult result) {
        Map<String, DuplicateObjectInfo> duplicateMap = new HashMap<>();

        IObjectList objects = snapshot.getObjects();

        for (IObject object : objects) {
            String className = object.getClazz().getName();

            DuplicateObjectInfo info = duplicateMap.get(className);
            if (info == null) {
                info = new DuplicateObjectInfo();
                info.setClassName(className);
                info.setCount(0);
                info.setTotalSize(0);
                duplicateMap.put(className, info);
            }

            info.setCount(info.getCount() + 1);
            info.setTotalSize(info.getTotalSize() + object.getUsedHeapSize());
        }

        // 按数量排序，找出重复最多的对象
        List<DuplicateObjectInfo> duplicates = duplicateMap.values().stream()
                .filter(info -> info.getCount() > 100) // 超过100个实例
                .sorted((a, b) -> Integer.compare(b.getCount(), a.getCount()))
                .collect(Collectors.toList());

        result.setDuplicateObjects(duplicates);
    }
}

/**
 * OOM自动处理服务
 */
@Service
public class OOMEmergencyHandler {

    @Autowired
    private ApplicationContext applicationContext;

    @Autowired
    private NotificationService notificationService;

    @Autowired
    private MetricsService metricsService;

    /**
     * OOM自动处理
     */
    @EventListener
    public void handleOOMEvent(OOMEvent event) {
        log.error("检测到OOM事件: {}", event);

        // 1. 立即通知相关人员
        notificationService.sendEmergencyNotification(event);

        // 2. 执行应急措施
        executeEmergencyMeasures(event);

        // 3. 记录OOM事件
        recordOOMEvent(event);

        // 4. 生成堆转储
        generateHeapDump(event);
    }

    /**
     * 执行应急措施
     */
    private void executeEmergencyMeasures(OOMEvent event) {
        try {
            // 1. 清理缓存
            clearCaches();

            // 2. 强制GC
            forceGarbageCollection();

            // 3. 服务降级
            degradeServices();

            // 4. 限制请求
            limitRequests();

        } catch (Exception e) {
            log.error("执行应急措施失败", e);
        }
    }

    /**
     * 清理缓存
     */
    private void clearCaches() {
        // 清理应用缓存
        CacheManager cacheManager = applicationContext.getBean(CacheManager.class);
        if (cacheManager != null) {
            cacheManager.getCacheNames().forEach(cacheName -> {
                Cache cache = cacheManager.getCache(cacheName);
                if (cache != null) {
                    cache.clear();
                }
            });
        }

        // 清理静态缓存
        System.gc();
    }

    /**
     * 强制垃圾回收
     */
    private void forceGarbageCollection() {
        // 多次执行GC
        for (int i = 0; i < 3; i++) {
            System.gc();
            System.runFinalization();

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
    }

    /**
     * 服务降级
     */
    private void degradeServices() {
        // 禁用非核心功能
        DegradationManager degradationManager = applicationContext.getBean(DegradationManager.class);
        degradationManager.enableDegradation();

        // 减少线程池大小
        ThreadPoolManager threadPoolManager = applicationContext.getBean(ThreadPoolManager.class);
        threadPoolManager.reduceThreadPoolSize();
    }

    /**
     * 限制请求
     */
    private void limitRequests() {
        // 启用限流
        RateLimiterManager rateLimiterManager = applicationContext.getBean(RateLimiterManager.class);
        rateLimiterManager.enableEmergencyRateLimit();
    }
}

/**
 * 内存监控与预警服务
 */
@Component
public class MemoryMonitoringService {

    @Autowired
    private MemoryMXBean memoryBean;

    @Autowired
    private AlertService alertService;

    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    /**
     * 启动内存监控
     */
    @PostConstruct
    public void startMemoryMonitoring() {
        scheduler.scheduleAtFixedRate(this::monitorMemoryUsage, 0, 30, TimeUnit.SECONDS);
    }

    /**
     * 监控内存使用情况
     */
    public void monitorMemoryUsage() {
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        double usagePercent = (double) heapUsage.getUsed() / heapUsage.getMax() * 100;

        // 内存使用率告警
        if (usagePercent > 90) {
            alertService.sendAlert(AlertLevel.CRITICAL, 
                "内存使用率过高: " + String.format("%.2f", usagePercent) + "%");
        } else if (usagePercent > 80) {
            alertService.sendAlert(AlertLevel.WARNING, 
                "内存使用率较高: " + String.format("%.2f", usagePercent) + "%");
        }

        // GC频率告警
        monitorGCFrequency();

        // 内存增长趋势告警
        monitorMemoryGrowthTrend();
    }

    /**
     * 监控GC频率
     */
    private void monitorGCFrequency() {
        List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans();

        for (GarbageCollectorMXBean gcBean : gcBeans) {
            long collectionCount = gcBean.getCollectionCount();
            long collectionTime = gcBean.getCollectionTime();

            // GC频率过高告警
            if (collectionCount > 1000) { // 假设阈值
                alertService.sendAlert(AlertLevel.WARNING, 
                    "GC频率过高: " + gcBean.getName() + " 执行次数: " + collectionCount);
            }

            // GC耗时过长告警
            if (collectionTime > 5000) { // 5秒
                alertService.sendAlert(AlertLevel.WARNING, 
                    "GC耗时过长: " + gcBean.getName() + " 耗时: " + collectionTime + "ms");
            }
        }
    }

    /**
     * 监控内存增长趋势
     */
    private void monitorMemoryGrowthTrend() {
        // 实现内存增长趋势监控逻辑
        // 如果内存持续增长且GC效果不佳，发送告警
    }
}

/**
 * 服务重启策略
 */
@Component
public class ServiceRestartStrategy {

    @Autowired
    private ApplicationContext applicationContext;

    /**
     * 优雅重启服务
     */
    public void gracefulRestart() {
        try {
            // 1. 停止接收新请求
            stopAcceptingNewRequests();

            // 2. 等待现有请求完成
            waitForExistingRequests();

            // 3. 保存状态
            saveApplicationState();

            // 4. 重启应用
            restartApplication();

        } catch (Exception e) {
            log.error("优雅重启失败，执行强制重启", e);
            forceRestart();
        }
    }

    /**
     * 停止接收新请求
     */
    private void stopAcceptingNewRequests() {
        // 设置应用状态为维护模式
        ApplicationStateManager stateManager = applicationContext.getBean(ApplicationStateManager.class);
        stateManager.setMaintenanceMode(true);

        // 停止负载均衡器健康检查
        HealthCheckManager healthCheckManager = applicationContext.getBean(HealthCheckManager.class);
        healthCheckManager.stopHealthCheck();
    }

    /**
     * 等待现有请求完成
     */
    private void waitForExistingRequests() {
        RequestTracker requestTracker = applicationContext.getBean(RequestTracker.class);

        // 等待最多5分钟
        long timeout = System.currentTimeMillis() + 300000;
        while (requestTracker.getActiveRequestCount() > 0 && System.currentTimeMillis() < timeout) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
    }

    /**
     * 保存应用状态
     */
    private void saveApplicationState() {
        // 保存缓存状态
        CacheStateManager cacheStateManager = applicationContext.getBean(CacheStateManager.class);
        cacheStateManager.saveCacheState();

        // 保存会话状态
        SessionStateManager sessionStateManager = applicationContext.getBean(SessionStateManager.class);
        sessionStateManager.saveSessionState();
    }
}

/**
 * GC优化服务
 */
@Service
public class GCOptimizationService {

    @Autowired
    private MemoryMXBean memoryBean;

    /**
     * GC性能分析
     */
    public GCAnalysisResult analyzeGCPerformance() {
        GCAnalysisResult result = new GCAnalysisResult();

        List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans();

        for (GarbageCollectorMXBean gcBean : gcBeans) {
            GCInfo gcInfo = new GCInfo();
            gcInfo.setName(gcBean.getName());
            gcInfo.setCollectionCount(gcBean.getCollectionCount());
            gcInfo.setCollectionTime(gcBean.getCollectionTime());

            // 计算平均GC时间
            if (gcInfo.getCollectionCount() > 0) {
                gcInfo.setAverageCollectionTime(
                    gcInfo.getCollectionTime() / gcInfo.getCollectionCount());
            }

            result.addGCInfo(gcInfo);
        }

        return result;
    }

    /**
     * GC调优建议
     */
    public List<GCTuningRecommendation> generateGCTuningRecommendations(GCAnalysisResult analysis) {
        List<GCTuningRecommendation> recommendations = new ArrayList<>();

        for (GCInfo gcInfo : analysis.getGcInfos()) {
            // GC频率过高
            if (gcInfo.getCollectionCount() > 1000) {
                recommendations.add(new GCTuningRecommendation(
                    "GC频率过高", 
                    "考虑增加堆内存大小或调整GC参数",
                    RecommendationPriority.HIGH));
            }

            // GC耗时过长
            if (gcInfo.getAverageCollectionTime() > 100) {
                recommendations.add(new GCTuningRecommendation(
                    "GC耗时过长", 
                    "考虑使用G1GC或调整GC参数",
                    RecommendationPriority.HIGH));
            }

            // 内存使用率过高
            MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
            double usagePercent = (double) heapUsage.getUsed() / heapUsage.getMax() * 100;
            if (usagePercent > 80) {
                recommendations.add(new GCTuningRecommendation(
                    "内存使用率过高", 
                    "考虑增加堆内存大小或优化代码",
                    RecommendationPriority.MEDIUM));
            }
        }

        return recommendations;
    }
}

/**
 * 对象池优化
 */
@Component
public class ObjectPoolOptimizationService {

    /**
     * 字符串对象池
     */
    private final Map<String, String> stringPool = new ConcurrentHashMap<>();

    /**
     * 字节数组对象池
     */
    private final Queue<byte[]> byteArrayPool = new ConcurrentLinkedQueue<>();

    /**
     * 获取字符串（使用对象池）
     */
    public String getString(String key) {
        return stringPool.computeIfAbsent(key, k -> new String(k));
    }

    /**
     * 获取字节数组（使用对象池）
     */
    public byte[] getByteArray(int size) {
        byte[] array = byteArrayPool.poll();
        if (array == null || array.length < size) {
            array = new byte[size];
        }
        return array;
    }

    /**
     * 归还字节数组到对象池
     */
    public void returnByteArray(byte[] array) {
        if (array != null && array.length <= 1024 * 1024) { // 限制大小
            byteArrayPool.offer(array);
        }
    }

    /**
     * 定期清理对象池
     */
    @Scheduled(fixedRate = 300000) // 5分钟
    public void cleanupObjectPool() {
        // 清理字符串池
        if (stringPool.size() > 10000) {
            stringPool.clear();
        }

        // 清理字节数组池
        while (byteArrayPool.size() > 100) {
            byteArrayPool.poll();
        }
    }
}

/**
 * 缓存优化服务
 */
@Service
public class CacheOptimizationService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private CaffeineCache localCache;

    /**
     * 多级缓存优化
     */
    public Object getWithOptimizedCache(String key) {
        // 1. 本地缓存
        Object value = localCache.getIfPresent(key);
        if (value != null) {
            return value;
        }

        // 2. Redis缓存
        value = redisTemplate.opsForValue().get(key);
        if (value != null) {
            localCache.put(key, value);
            return value;
        }

        // 3. 数据库查询
        value = loadFromDatabase(key);
        if (value != null) {
            // 异步写入缓存
            CompletableFuture.runAsync(() -> {
                redisTemplate.opsForValue().set(key, value, Duration.ofMinutes(30));
                localCache.put(key, value);
            });
        }

        return value;
    }

    /**
     * 缓存预热
     */
    @PostConstruct
    public void warmUpCache() {
        List<String> hotKeys = getHotKeys();

        // 并行预热缓存
        hotKeys.parallelStream().forEach(key -> {
            Object value = loadFromDatabase(key);
            if (value != null) {
                redisTemplate.opsForValue().set(key, value, Duration.ofHours(1));
                localCache.put(key, value);
            }
        });
    }

    /**
     * 缓存清理策略
     */
    @Scheduled(fixedRate = 3600000) // 1小时
    public void cleanupCache() {
        // 清理本地缓存
        localCache.cleanUp();

        // 清理Redis中的过期缓存
        Set<String> keys = redisTemplate.keys("*");
        if (keys != null && keys.size() > 10000) {
            // 随机清理部分缓存
            keys.stream()
                .limit(1000)
                .forEach(key -> redisTemplate.delete(key));
        }
    }
}

/**
 * JVM内存监控指标
 */
@Component
public class JVMMemoryMetrics {

    private final MeterRegistry meterRegistry;

    public JVMMemoryMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }

    @Scheduled(fixedRate = 10000)
    public void collectJVMMemoryMetrics() {
        MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();

        // 堆内存监控
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        Gauge.builder("jvm.memory.heap.used")
                .description("堆内存使用量")
                .register(meterRegistry, () -> heapUsage.getUsed());

        Gauge.builder("jvm.memory.heap.max")
                .description("堆内存最大值")
                .register(meterRegistry, () -> heapUsage.getMax());

        Gauge.builder("jvm.memory.heap.usage")
                .description("堆内存使用率")
                .register(meterRegistry, () -> 
                    (double) heapUsage.getUsed() / heapUsage.getMax() * 100);

        // 非堆内存监控
        MemoryUsage nonHeapUsage = memoryBean.getNonHeapMemoryUsage();
        Gauge.builder("jvm.memory.nonheap.used")
                .description("非堆内存使用量")
                .register(meterRegistry, () -> nonHeapUsage.getUsed());

        Gauge.builder("jvm.memory.nonheap.max")
                .description("非堆内存最大值")
                .register(meterRegistry, () -> nonHeapUsage.getMax());

        // GC监控
        collectGCMetrics();

        // 类加载监控
        collectClassLoadingMetrics();
    }

    /**
     * 收集GC指标
     */
    private void collectGCMetrics() {
        List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans();

        for (GarbageCollectorMXBean gcBean : gcBeans) {
            String gcName = gcBean.getName().replaceAll("[^a-zA-Z0-9]", "_");

            Gauge.builder("jvm.gc.collection.count")
                    .description("GC收集次数")
                    .tag("gc", gcName)
                    .register(meterRegistry, () -> gcBean.getCollectionCount());

            Gauge.builder("jvm.gc.collection.time")
                    .description("GC收集时间")
                    .tag("gc", gcName)
                    .register(meterRegistry, () -> gcBean.getCollectionTime());
        }
    }

    /**
     * 收集类加载指标
     */
    private void collectClassLoadingMetrics() {
        ClassLoadingMXBean classBean = ManagementFactory.getClassLoadingMXBean();

        Gauge.builder("jvm.classes.loaded")
                .description("已加载类数量")
                .register(meterRegistry, () -> classBean.getLoadedClassCount());

        Gauge.builder("jvm.classes.unloaded")
                .description("已卸载类数量")
                .register(meterRegistry, () -> classBean.getUnloadedClassCount());
    }
}

/**
 * 应用内存监控
 */
@Component
public class ApplicationMemoryMetrics {

    private final MeterRegistry meterRegistry;

    public ApplicationMemoryMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }

    /**
     * 监控对象创建
     */
    public void recordObjectCreation(String objectType, int size) {
        Counter.builder("application.objects.created")
                .description("对象创建次数")
                .tag("type", objectType)
                .register(meterRegistry)
                .increment();

        Timer.builder("application.objects.size")
                .description("对象大小")
                .tag("type", objectType)
                .register(meterRegistry)
                .record(size, TimeUnit.BYTES);
    }

    /**
     * 监控缓存使用
     */
    public void recordCacheUsage(String cacheName, int hitCount, int missCount) {
        Counter.builder("application.cache.hits")
                .description("缓存命中次数")
                .tag("cache", cacheName)
                .register(meterRegistry)
                .increment(hitCount);

        Counter.builder("application.cache.misses")
                .description("缓存未命中次数")
                .tag("cache", cacheName)
                .register(meterRegistry)
                .increment(missCount);
    }

    /**
     * 监控内存泄漏
     */
    public void recordMemoryLeak(String leakType, long leakSize) {
        Counter.builder("application.memory.leak")
                .description("内存泄漏")
                .tag("type", leakType)
                .register(meterRegistry)
                .increment();

        Gauge.builder("application.memory.leak.size")
                .description("内存泄漏大小")
                .tag("type", leakType)
                .register(meterRegistry, () -> leakSize);
    }
}

/**
 * 智能OOM告警处理
 */
@Service
public class IntelligentOOMAlertHandler {

    @Autowired
    private AlertService alertService;

    @Autowired
    private MemoryAnalysisService memoryAnalysisService;

    @Autowired
    private EmergencyResponseService emergencyResponse;

    /**
     * 处理OOM告警
     */
    @EventListener
    public void handleOOMAlert(OOMAlertEvent event) {
        log.warn("收到OOM告警: {}", event);

        // 1. 分析告警严重程度
        AlertSeverity severity = analyzeAlertSeverity(event);

        // 2. 执行相应的处理措施
        switch (severity) {
            case CRITICAL:
                handleCriticalAlert(event);
                break;
            case WARNING:
                handleWarningAlert(event);
                break;
            case INFO:
                handleInfoAlert(event);
                break;
        }

        // 3. 记录告警处理结果
        recordAlertHandling(event, severity);
    }

    /**
     * 分析告警严重程度
     */
    private AlertSeverity analyzeAlertSeverity(OOMAlertEvent event) {
        // 基于历史数据和当前状态分析严重程度
        MemoryAnalysisResult analysis = memoryAnalysisService.analyzeCurrentMemory();

        if (analysis.getMemoryUsagePercent() > 95) {
            return AlertSeverity.CRITICAL;
        } else if (analysis.getMemoryUsagePercent() > 85) {
            return AlertSeverity.WARNING;
        } else {
            return AlertSeverity.INFO;
        }
    }

    /**
     * 处理严重告警
     */
    private void handleCriticalAlert(OOMAlertEvent event) {
        // 1. 立即通知相关人员
        alertService.sendCriticalAlert(event);

        // 2. 启动应急响应
        emergencyResponse.activateEmergencyMode();

        // 3. 执行应急措施
        emergencyResponse.executeEmergencyMeasures();

        // 4. 生成堆转储
        generateHeapDump(event);
    }

    /**
     * 处理警告告警
     */
    private void handleWarningAlert(OOMAlertEvent event) {
        // 1. 发送警告通知
        alertService.sendWarningAlert(event);

        // 2. 执行预防措施
        executePreventiveMeasures(event);

        // 3. 增加监控频率
        increaseMonitoringFrequency();
    }

    /**
     * 生成堆转储
     */
    private void generateHeapDump(OOMAlertEvent event) {
        try {
            String fileName = "heap_dump_" + System.currentTimeMillis() + ".hprof";
            HotSpotDiagnosticMXBean diagnosticBean = ManagementFactory.getPlatformMXBean(HotSpotDiagnosticMXBean.class);
            diagnosticBean.dumpHeap(fileName, true);

            log.info("堆转储已生成: {}", fileName);

            // 异步分析堆转储
            CompletableFuture.runAsync(() -> {
                analyzeHeapDump(fileName);
            });

        } catch (Exception e) {
            log.error("生成堆转储失败", e);
        }
    }
}