第188集Java堆中大对象创建与内存优化策略

// 内存监控工具
@Component
public class MemoryMonitor {
    private final MemoryMXBean memoryBean;
    private final List<GarbageCollectorMXBean> gcBeans;
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    public MemoryMonitor() {
        this.memoryBean = ManagementFactory.getMemoryMXBean();
        this.gcBeans = ManagementFactory.getGarbageCollectorMXBeans();

        // 启动内存监控
        scheduler.scheduleAtFixedRate(this::monitorMemory, 0, 5, TimeUnit.SECONDS);
    }

    private void monitorMemory() {
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        double usageRatio = (double) heapUsage.getUsed() / heapUsage.getMax();

        System.out.println("=== 内存使用情况 ===");
        System.out.println("堆内存使用: " + formatBytes(heapUsage.getUsed()) + 
                         " / " + formatBytes(heapUsage.getMax()));
        System.out.println("使用率: " + String.format("%.2f%%", usageRatio * 100));

        if (usageRatio > 0.8) {
            System.out.println("警告: 内存使用率过高!");
            analyzeMemoryUsage();
        }

        // 监控GC情况
        monitorGC();
    }

    private void analyzeMemoryUsage() {
        // 分析内存使用情况
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        MemoryUsage nonHeapUsage = memoryBean.getNonHeapMemoryUsage();

        System.out.println("=== 内存分析 ===");
        System.out.println("堆内存: " + formatBytes(heapUsage.getUsed()));
        System.out.println("非堆内存: " + formatBytes(nonHeapUsage.getUsed()));

        // 检查是否有大对象
        checkLargeObjects();
    }

    private void checkLargeObjects() {
        // 使用JVM工具检查大对象
        System.out.println("检查大对象...");

        // 这里可以集成JProfiler、VisualVM等工具
        // 或者使用JVM参数 -XX:+HeapDumpOnOutOfMemoryError
    }

    private void monitorGC() {
        System.out.println("=== GC情况 ===");
        for (GarbageCollectorMXBean gcBean : gcBeans) {
            System.out.println(gcBean.getName() + ": " + gcBean.getCollectionCount() + 
                             " 次, " + gcBean.getCollectionTime() + " ms");
        }
    }

    private String formatBytes(long bytes) {
        if (bytes < 1024) return bytes + " B";
        if (bytes < 1024 * 1024) return String.format("%.2f KB", bytes / 1024.0);
        if (bytes < 1024 * 1024 * 1024) return String.format("%.2f MB", bytes / (1024.0 * 1024.0));
        return String.format("%.2f GB", bytes / (1024.0 * 1024.0 * 1024.0));
    }

    public boolean isMemoryHigh() {
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        double usageRatio = (double) heapUsage.getUsed() / heapUsage.getMax();
        return usageRatio > 0.8;
    }
}

// 大对象检测器
@Component
public class LargeObjectDetector {
    private final MemoryMXBean memoryBean;
    private final List<LargeObjectInfo> largeObjects = new ArrayList<>();

    public LargeObjectDetector() {
        this.memoryBean = ManagementFactory.getMemoryMXBean();
    }

    public void detectLargeObjects() {
        // 检测大对象
        System.out.println("开始检测大对象...");

        // 这里可以使用字节码增强技术检测大对象创建
        // 或者使用JVM参数 -XX:+TraceClassLoading
    }

    public void trackObjectCreation(Object obj) {
        if (obj == null) return;

        long objectSize = estimateObjectSize(obj);
        if (objectSize > 1024 * 1024) { // 1MB
            LargeObjectInfo info = new LargeObjectInfo(
                obj.getClass().getName(),
                objectSize,
                System.currentTimeMillis()
            );
            largeObjects.add(info);

            System.out.println("检测到大对象: " + info);
        }
    }

    private long estimateObjectSize(Object obj) {
        if (obj instanceof String) {
            return ((String) obj).length() * 2; // 每个字符2字节
        } else if (obj instanceof byte[]) {
            return ((byte[]) obj).length;
        } else if (obj instanceof int[]) {
            return ((int[]) obj).length * 4; // 每个int 4字节
        } else if (obj instanceof long[]) {
            return ((long[]) obj).length * 8; // 每个long 8字节
        } else if (obj instanceof Collection) {
            Collection<?> collection = (Collection<?>) obj;
            return collection.size() * 16; // 估算每个元素16字节
        } else if (obj instanceof Map) {
            Map<?, ?> map = (Map<?, ?>) obj;
            return map.size() * 32; // 估算每个键值对32字节
        }

        return 0; // 无法估算
    }

    public List<LargeObjectInfo> getLargeObjects() {
        return new ArrayList<>(largeObjects);
    }

    // 大对象信息
    public static class LargeObjectInfo {
        private String className;
        private long size;
        private long timestamp;

        public LargeObjectInfo(String className, long size, long timestamp) {
            this.className = className;
            this.size = size;
            this.timestamp = timestamp;
        }

        @Override
        public String toString() {
            return String.format("LargeObject[%s, %d bytes, %d]", 
                                className, size, timestamp);
        }

        // getters and setters
        public String getClassName() { return className; }
        public long getSize() { return size; }
        public long getTimestamp() { return timestamp; }
    }
}

// 大对象池实现
@Component
public class LargeObjectPool {
    private final Map<String, Queue<Object>> objectPools = new ConcurrentHashMap<>();
    private final Map<String, AtomicInteger> poolSizes = new ConcurrentHashMap<>();
    private final int maxPoolSize = 100;

    public <T> T borrowObject(Class<T> clazz) {
        String className = clazz.getName();
        Queue<Object> pool = objectPools.computeIfAbsent(className, k -> new ConcurrentLinkedQueue<>());

        Object obj = pool.poll();
        if (obj == null) {
            try {
                obj = clazz.newInstance();
            } catch (Exception e) {
                throw new RuntimeException("创建对象失败", e);
            }
        }

        return (T) obj;
    }

    public void returnObject(Object obj) {
        if (obj == null) return;

        String className = obj.getClass().getName();
        Queue<Object> pool = objectPools.get(className);

        if (pool != null) {
            AtomicInteger size = poolSizes.computeIfAbsent(className, k -> new AtomicInteger(0));

            if (size.get() < maxPoolSize) {
                // 清理对象状态
                clearObjectState(obj);

                pool.offer(obj);
                size.incrementAndGet();
            }
        }
    }

    private void clearObjectState(Object obj) {
        if (obj instanceof Collection) {
            ((Collection<?>) obj).clear();
        } else if (obj instanceof Map) {
            ((Map<?, ?>) obj).clear();
        } else if (obj instanceof StringBuilder) {
            ((StringBuilder) obj).setLength(0);
        } else if (obj instanceof ByteArrayOutputStream) {
            ((ByteArrayOutputStream) obj).reset();
        }
        // 可以根据需要添加更多类型的清理逻辑
    }

    public void clearPool(String className) {
        Queue<Object> pool = objectPools.remove(className);
        if (pool != null) {
            pool.clear();
        }
        poolSizes.remove(className);
    }

    public void clearAllPools() {
        objectPools.clear();
        poolSizes.clear();
    }

    public Map<String, Integer> getPoolSizes() {
        Map<String, Integer> sizes = new HashMap<>();
        for (Map.Entry<String, AtomicInteger> entry : poolSizes.entrySet()) {
            sizes.put(entry.getKey(), entry.getValue().get());
        }
        return sizes;
    }
}

// 线程本地对象池
@Component
public class ThreadLocalObjectPool {
    private final ThreadLocal<Map<String, Object>> threadLocalObjects = new ThreadLocal<Map<String, Object>>() {
        @Override
        protected Map<String, Object> initialValue() {
            return new HashMap<>();
        }
    };

    public <T> T getObject(Class<T> clazz) {
        String className = clazz.getName();
        Map<String, Object> objects = threadLocalObjects.get();

        Object obj = objects.get(className);
        if (obj == null) {
            try {
                obj = clazz.newInstance();
                objects.put(className, obj);
            } catch (Exception e) {
                throw new RuntimeException("创建对象失败", e);
            }
        }

        return (T) obj;
    }

    public void clearObject(String className) {
        Map<String, Object> objects = threadLocalObjects.get();
        Object obj = objects.get(className);

        if (obj != null) {
            clearObjectState(obj);
        }
    }

    public void clearAllObjects() {
        Map<String, Object> objects = threadLocalObjects.get();
        for (Object obj : objects.values()) {
            clearObjectState(obj);
        }
        objects.clear();
    }

    private void clearObjectState(Object obj) {
        if (obj instanceof Collection) {
            ((Collection<?>) obj).clear();
        } else if (obj instanceof Map) {
            ((Map<?, ?>) obj).clear();
        } else if (obj instanceof StringBuilder) {
            ((StringBuilder) obj).setLength(0);
        } else if (obj instanceof ByteArrayOutputStream) {
            ((ByteArrayOutputStream) obj).reset();
        }
    }

    public void remove() {
        threadLocalObjects.remove();
    }
}

// 对象复用策略
@Service
public class ObjectReuseStrategy {
    private final LargeObjectPool objectPool;
    private final ThreadLocalObjectPool threadLocalPool;

    public ObjectReuseStrategy(LargeObjectPool objectPool,
                              ThreadLocalObjectPool threadLocalPool) {
        this.objectPool = objectPool;
        this.threadLocalPool = threadLocalPool;
    }

    // 使用对象池
    public <T> T usePooledObject(Class<T> clazz, Consumer<T> operation) {
        T obj = objectPool.borrowObject(clazz);
        try {
            operation.accept(obj);
            return obj;
        } finally {
            objectPool.returnObject(obj);
        }
    }

    // 使用线程本地对象
    public <T> T useThreadLocalObject(Class<T> clazz, Consumer<T> operation) {
        T obj = threadLocalPool.getObject(clazz);
        operation.accept(obj);
        return obj;
    }

    // 批量处理
    public <T> void batchProcess(Class<T> clazz, List<Consumer<T>> operations) {
        T obj = objectPool.borrowObject(clazz);
        try {
            for (Consumer<T> operation : operations) {
                operation.accept(obj);
            }
        } finally {
            objectPool.returnObject(obj);
        }
    }

    // 流式处理
    public <T> void streamProcess(Class<T> clazz, Stream<Consumer<T>> operations) {
        T obj = objectPool.borrowObject(clazz);
        try {
            operations.forEach(operation -> operation.accept(obj));
        } finally {
            objectPool.returnObject(obj);
        }
    }
}

// 大对象拆分策略
@Service
public class LargeObjectSplitStrategy {

    // 拆分大数组
    public <T> List<T[]> splitArray(T[] largeArray, int chunkSize) {
        List<T[]> chunks = new ArrayList<>();

        for (int i = 0; i < largeArray.length; i += chunkSize) {
            int endIndex = Math.min(i + chunkSize, largeArray.length);
            T[] chunk = Arrays.copyOfRange(largeArray, i, endIndex);
            chunks.add(chunk);
        }

        return chunks;
    }

    // 拆分大集合
    public <T> List<List<T>> splitCollection(Collection<T> largeCollection, int chunkSize) {
        List<List<T>> chunks = new ArrayList<>();
        List<T> list = new ArrayList<>(largeCollection);

        for (int i = 0; i < list.size(); i += chunkSize) {
            int endIndex = Math.min(i + chunkSize, list.size());
            List<T> chunk = list.subList(i, endIndex);
            chunks.add(new ArrayList<>(chunk));
        }

        return chunks;
    }

    // 拆分大字符串
    public List<String> splitString(String largeString, int chunkSize) {
        List<String> chunks = new ArrayList<>();

        for (int i = 0; i < largeString.length(); i += chunkSize) {
            int endIndex = Math.min(i + chunkSize, largeString.length());
            String chunk = largeString.substring(i, endIndex);
            chunks.add(chunk);
        }

        return chunks;
    }

    // 拆分大字节数组
    public List<byte[]> splitByteArray(byte[] largeArray, int chunkSize) {
        List<byte[]> chunks = new ArrayList<>();

        for (int i = 0; i < largeArray.length; i += chunkSize) {
            int endIndex = Math.min(i + chunkSize, largeArray.length);
            byte[] chunk = Arrays.copyOfRange(largeArray, i, endIndex);
            chunks.add(chunk);
        }

        return chunks;
    }

    // 流式处理大对象
    public <T> void processLargeObjectStream(Collection<T> largeCollection, 
                                           Consumer<List<T>> processor, 
                                           int batchSize) {
        List<T> list = new ArrayList<>(largeCollection);

        for (int i = 0; i < list.size(); i += batchSize) {
            int endIndex = Math.min(i + batchSize, list.size());
            List<T> batch = list.subList(i, endIndex);

            processor.accept(batch);

            // 清理引用
            batch.clear();

            // 强制GC
            if (i % (batchSize * 10) == 0) {
                System.gc();
            }
        }
    }
}

// 内存压缩策略
@Service
public class MemoryCompressionStrategy {

    // 压缩字符串
    public byte[] compressString(String str) {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            GZIPOutputStream gzos = new GZIPOutputStream(baos);
            gzos.write(str.getBytes("UTF-8"));
            gzos.close();
            return baos.toByteArray();
        } catch (Exception e) {
            throw new RuntimeException("压缩字符串失败", e);
        }
    }

    // 解压字符串
    public String decompressString(byte[] compressedData) {
        try {
            ByteArrayInputStream bais = new ByteArrayInputStream(compressedData);
            GZIPInputStream gzis = new GZIPInputStream(bais);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();

            byte[] buffer = new byte[1024];
            int len;
            while ((len = gzis.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }

            gzis.close();
            return baos.toString("UTF-8");
        } catch (Exception e) {
            throw new RuntimeException("解压字符串失败", e);
        }
    }

    // 压缩字节数组
    public byte[] compressByteArray(byte[] data) {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            GZIPOutputStream gzos = new GZIPOutputStream(baos);
            gzos.write(data);
            gzos.close();
            return baos.toByteArray();
        } catch (Exception e) {
            throw new RuntimeException("压缩字节数组失败", e);
        }
    }

    // 解压字节数组
    public byte[] decompressByteArray(byte[] compressedData) {
        try {
            ByteArrayInputStream bais = new ByteArrayInputStream(compressedData);
            GZIPInputStream gzis = new GZIPInputStream(bais);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();

            byte[] buffer = new byte[1024];
            int len;
            while ((len = gzis.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }

            gzis.close();
            return baos.toByteArray();
        } catch (Exception e) {
            throw new RuntimeException("解压字节数组失败", e);
        }
    }

    // 压缩对象
    public byte[] compressObject(Object obj) {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(obj);
            oos.close();

            byte[] serializedData = baos.toByteArray();
            return compressByteArray(serializedData);
        } catch (Exception e) {
            throw new RuntimeException("压缩对象失败", e);
        }
    }

    // 解压对象
    public Object decompressObject(byte[] compressedData) {
        try {
            byte[] decompressedData = decompressByteArray(compressedData);

            ByteArrayInputStream bais = new ByteArrayInputStream(decompressedData);
            ObjectInputStream ois = new ObjectInputStream(bais);
            Object obj = ois.readObject();
            ois.close();

            return obj;
        } catch (Exception e) {
            throw new RuntimeException("解压对象失败", e);
        }
    }
}

// 内存泄漏防护
@Component
public class MemoryLeakPrevention {
    private final WeakHashMap<String, Object> cache = new WeakHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
    private final List<WeakReference<Object>> trackedObjects = new ArrayList<>();

    @PostConstruct
    public void init() {
        // 定期清理缓存
        scheduler.scheduleAtFixedRate(this::cleanupCache, 0, 10, TimeUnit.MINUTES);

        // 定期检查内存使用
        scheduler.scheduleAtFixedRate(this::checkMemoryUsage, 0, 1, TimeUnit.MINUTES);

        // 定期清理跟踪对象
        scheduler.scheduleAtFixedRate(this::cleanupTrackedObjects, 0, 5, TimeUnit.MINUTES);
    }

    private void cleanupCache() {
        synchronized (cache) {
            cache.clear();
        }
        System.gc();
    }

    private void checkMemoryUsage() {
        MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();

        double usageRatio = (double) heapUsage.getUsed() / heapUsage.getMax();
        if (usageRatio > 0.9) {
            System.out.println("内存使用率过高: " + String.format("%.2f%%", usageRatio * 100));
            cleanupCache();
            cleanupTrackedObjects();
        }
    }

    private void cleanupTrackedObjects() {
        trackedObjects.removeIf(ref -> ref.get() == null);
    }

    public void trackObject(Object obj) {
        trackedObjects.add(new WeakReference<>(obj));
    }

    public void addToCache(String key, Object value) {
        synchronized (cache) {
            cache.put(key, value);
        }
    }

    public Object getFromCache(String key) {
        synchronized (cache) {
            return cache.get(key);
        }
    }

    public void clearCache() {
        synchronized (cache) {
            cache.clear();
        }
    }

    public int getTrackedObjectCount() {
        return trackedObjects.size();
    }
}

// GC监控与调优
@Component
public class GCMonitor {
    private final List<GarbageCollectorMXBean> gcBeans;
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    public GCMonitor() {
        this.gcBeans = ManagementFactory.getGarbageCollectorMXBeans();

        // 启动GC监控
        scheduler.scheduleAtFixedRate(this::monitorGC, 0, 10, TimeUnit.SECONDS);
    }

    private void monitorGC() {
        System.out.println("=== GC监控 ===");

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

            System.out.println(gcBean.getName() + ":");
            System.out.println("  收集次数: " + collectionCount);
            System.out.println("  收集时间: " + collectionTime + " ms");

            // 检查GC频率
            if (collectionCount > 0) {
                double avgCollectionTime = (double) collectionTime / collectionCount;
                System.out.println("  平均收集时间: " + String.format("%.2f", avgCollectionTime) + " ms");

                if (avgCollectionTime > 100) {
                    System.out.println("  警告: GC时间过长!");
                }
            }
        }

        // 检查内存使用
        checkMemoryUsage();
    }

    private void checkMemoryUsage() {
        MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();

        System.out.println("=== 内存使用 ===");
        System.out.println("堆内存使用: " + formatBytes(heapUsage.getUsed()) + 
                         " / " + formatBytes(heapUsage.getMax()));

        double usageRatio = (double) heapUsage.getUsed() / heapUsage.getMax();
        System.out.println("使用率: " + String.format("%.2f%%", usageRatio * 100));

        if (usageRatio > 0.8) {
            System.out.println("警告: 内存使用率过高!");
            suggestGC();
        }
    }

    private void suggestGC() {
        System.out.println("建议执行以下操作:");
        System.out.println("1. 清理缓存");
        System.out.println("2. 释放大对象");
        System.out.println("3. 调整JVM参数");
        System.out.println("4. 优化代码逻辑");
    }

    private String formatBytes(long bytes) {
        if (bytes < 1024) return bytes + " B";
        if (bytes < 1024 * 1024) return String.format("%.2f KB", bytes / 1024.0);
        if (bytes < 1024 * 1024 * 1024) return String.format("%.2f MB", bytes / (1024.0 * 1024.0));
        return String.format("%.2f GB", bytes / (1024.0 * 1024.0 * 1024.0));
    }

    public void forceGC() {
        System.out.println("强制执行GC...");
        System.gc();
    }
}

// 大文件处理优化
@Service
public class LargeFileProcessor {
    private final ObjectReuseStrategy objectReuseStrategy;
    private final MemoryCompressionStrategy compressionStrategy;

    public LargeFileProcessor(ObjectReuseStrategy objectReuseStrategy,
                             MemoryCompressionStrategy compressionStrategy) {
        this.objectReuseStrategy = objectReuseStrategy;
        this.compressionStrategy = compressionStrategy;
    }

    // 流式处理大文件
    public void processLargeFile(String filePath, Consumer<String> processor) {
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            StringBuilder buffer = objectReuseStrategy.useThreadLocalObject(StringBuilder.class, sb -> {
                // 初始化StringBuilder
            });

            while ((line = reader.readLine()) != null) {
                buffer.append(line).append("\n");

                // 当缓冲区达到一定大小时处理
                if (buffer.length() > 1024 * 1024) { // 1MB
                    processor.accept(buffer.toString());
                    buffer.setLength(0); // 清空缓冲区
                }
            }

            // 处理剩余内容
            if (buffer.length() > 0) {
                processor.accept(buffer.toString());
            }

        } catch (IOException e) {
            throw new RuntimeException("处理大文件失败", e);
        }
    }

    // 压缩存储大文件内容
    public void compressAndStoreFile(String filePath, String outputPath) {
        try {
            // 读取文件内容
            byte[] fileContent = Files.readAllBytes(Paths.get(filePath));

            // 压缩内容
            byte[] compressedContent = compressionStrategy.compressByteArray(fileContent);

            // 写入压缩文件
            Files.write(Paths.get(outputPath), compressedContent);

        } catch (IOException e) {
            throw new RuntimeException("压缩存储文件失败", e);
        }
    }

    // 分批处理大文件
    public void processLargeFileInBatches(String filePath, Consumer<List<String>> batchProcessor, int batchSize) {
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            List<String> batch = new ArrayList<>();
            String line;

            while ((line = reader.readLine()) != null) {
                batch.add(line);

                if (batch.size() >= batchSize) {
                    batchProcessor.accept(batch);
                    batch.clear(); // 清空批次
                }
            }

            // 处理剩余批次
            if (!batch.isEmpty()) {
                batchProcessor.accept(batch);
            }

        } catch (IOException e) {
            throw new RuntimeException("分批处理大文件失败", e);
        }
    }
}

// 大数据集处理优化
@Service
public class LargeDatasetProcessor {
    private final LargeObjectPool objectPool;
    private final LargeObjectSplitStrategy splitStrategy;

    public LargeDatasetProcessor(LargeObjectPool objectPool,
                                LargeObjectSplitStrategy splitStrategy) {
        this.objectPool = objectPool;
        this.splitStrategy = splitStrategy;
    }

    // 处理大数据集
    public <T> void processLargeDataset(Collection<T> dataset, Consumer<List<T>> processor) {
        // 拆分大数据集
        List<List<T>> chunks = splitStrategy.splitCollection(dataset, 1000);

        // 并行处理分片
        chunks.parallelStream().forEach(chunk -> {
            processor.accept(chunk);

            // 清理分片
            chunk.clear();
        });
    }

    // 流式处理大数据集
    public <T> void processLargeDatasetStream(Collection<T> dataset, 
                                            Consumer<List<T>> processor, 
                                            int batchSize) {
        splitStrategy.processLargeObjectStream(dataset, processor, batchSize);
    }

    // 内存友好的数据处理
    public <T, R> List<R> processLargeDatasetWithMapper(Collection<T> dataset, 
                                                       Function<List<T>, List<R>> mapper, 
                                                       int batchSize) {
        List<R> results = new ArrayList<>();

        splitStrategy.processLargeObjectStream(dataset, batch -> {
            List<R> batchResults = mapper.apply(batch);
            results.addAll(batchResults);

            // 清理批次
            batch.clear();
            batchResults.clear();
        }, batchSize);

        return results;
    }
}

// 性能监控
@Component
public class PerformanceMonitor {
    private final MeterRegistry meterRegistry;
    private final Timer objectCreationTimer;
    private final Counter largeObjectCounter;
    private final Gauge memoryUsageGauge;

    public PerformanceMonitor(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.objectCreationTimer = Timer.builder("object.creation.time")
            .register(meterRegistry);
        this.largeObjectCounter = Counter.builder("large.object.count")
            .register(meterRegistry);
        this.memoryUsageGauge = Gauge.builder("memory.usage")
            .register(meterRegistry, this, PerformanceMonitor::getMemoryUsage);
    }

    public <T> T monitorObjectCreation(Supplier<T> objectCreator, String objectType) {
        Timer.Sample sample = Timer.start(meterRegistry);
        try {
            T result = objectCreator.get();

            // 检查是否为大对象
            if (isLargeObject(result)) {
                largeObjectCounter.increment(Tags.of("type", objectType));
            }

            return result;
        } finally {
            sample.stop(Timer.builder("object.creation.time")
                .tag("type", objectType)
                .register(meterRegistry));
        }
    }

    private boolean isLargeObject(Object obj) {
        if (obj instanceof String) {
            return ((String) obj).length() > 100000; // 100KB
        } else if (obj instanceof byte[]) {
            return ((byte[]) obj).length > 1024 * 1024; // 1MB
        } else if (obj instanceof Collection) {
            return ((Collection<?>) obj).size() > 10000;
        } else if (obj instanceof Map) {
            return ((Map<?, ?>) obj).size() > 10000;
        }
        return false;
    }

    private double getMemoryUsage() {
        MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        return (double) heapUsage.getUsed() / heapUsage.getMax();
    }
}

// 性能调优建议
@Service
public class PerformanceTuningService {
    private final MemoryMonitor memoryMonitor;
    private final GCMonitor gcMonitor;
    private final PerformanceMonitor performanceMonitor;

    public PerformanceTuningService(MemoryMonitor memoryMonitor,
                                   GCMonitor gcMonitor,
                                   PerformanceMonitor performanceMonitor) {
        this.memoryMonitor = memoryMonitor;
        this.gcMonitor = gcMonitor;
        this.performanceMonitor = performanceMonitor;
    }

    public void optimizePerformance() {
        if (memoryMonitor.isMemoryHigh()) {
            System.out.println("内存使用率过高，开始性能优化...");

            // 1. 清理缓存
            System.gc();

            // 2. 调整JVM参数
            adjustJVMParameters();

            // 3. 优化对象创建
            optimizeObjectCreation();

            // 4. 优化GC
            optimizeGC();
        }
    }

    private void adjustJVMParameters() {
        System.out.println("调整JVM参数...");

        // 这里可以添加动态调整JVM参数的逻辑
        // 注意：大多数JVM参数在运行时无法修改
    }

    private void optimizeObjectCreation() {
        System.out.println("优化对象创建...");

        // 建议使用对象池
        // 建议使用线程本地对象
        // 建议避免创建大对象
    }

    private void optimizeGC() {
        System.out.println("优化GC...");

        // 强制执行GC
        gcMonitor.forceGC();

        // 分析GC日志
        analyzeGCLogs();
    }

    private void analyzeGCLogs() {
        System.out.println("分析GC日志...");

        // 这里可以添加GC日志分析逻辑
    }
}