// 线程池内存占用计算器
@Component
public class ThreadPoolMemoryCalculator {
    
    private final MemoryAnalyzer memoryAnalyzer;
    private final ThreadPoolMonitor threadPoolMonitor;
    
    /**
     * 计算线程池总内存占用
     */
    public ThreadPoolMemoryUsage calculateTotalMemoryUsage(ThreadPoolExecutor executor) {
        ThreadPoolMemoryUsage usage = new ThreadPoolMemoryUsage();
        
        // 1. 计算线程栈内存
        long threadStackMemory = calculateThreadStackMemory(executor);
        usage.setThreadStackMemory(threadStackMemory);
        
        // 2. 计算任务队列内存
        long taskQueueMemory = calculateTaskQueueMemory(executor);
        usage.setTaskQueueMemory(taskQueueMemory);
        
        // 3. 计算线程对象内存
        long threadObjectMemory = calculateThreadObjectMemory(executor);
        usage.setThreadObjectMemory(threadObjectMemory);
        
        // 4. 计算任务对象内存
        long taskObjectMemory = calculateTaskObjectMemory(executor);
        usage.setTaskObjectMemory(taskObjectMemory);
        
        // 5. 计算总内存占用
        long totalMemory = threadStackMemory + taskQueueMemory + 
                          threadObjectMemory + taskObjectMemory;
        usage.setTotalMemory(totalMemory);
        
        // 6. 计算内存使用率
        double memoryUsageRate = calculateMemoryUsageRate(totalMemory);
        usage.setMemoryUsageRate(memoryUsageRate);
        
        return usage;
    }
    
    /**
     * 计算线程栈内存
     */
    private long calculateThreadStackMemory(ThreadPoolExecutor executor) {
        // 获取当前活跃线程数
        int activeThreads = executor.getActiveCount();
        
        // 获取线程栈大小
        long stackSize = getThreadStackSize();
        
        // 计算总栈内存
        return (long) activeThreads * stackSize;
    }
    
    /**
     * 计算任务队列内存
     */
    private long calculateTaskQueueMemory(ThreadPoolExecutor executor) {
        BlockingQueue<Runnable> queue = executor.getQueue();
        
        // 获取队列大小
        int queueSize = queue.size();
        
        // 估算单个任务的平均内存占用
        long averageTaskSize = estimateAverageTaskSize();
        
        // 计算队列总内存
        return (long) queueSize * averageTaskSize;
    }
    
    /**
     * 计算线程对象内存
     */
    private long calculateThreadObjectMemory(ThreadPoolExecutor executor) {
        // 获取线程池中的线程数
        int threadCount = executor.getPoolSize();
        
        // 估算单个Thread对象的内存占用
        long threadObjectSize = estimateThreadObjectSize();
        
        // 计算线程对象总内存
        return (long) threadCount * threadObjectSize;
    }
    
    /**
     * 计算任务对象内存
     */
    private long calculateTaskObjectMemory(ThreadPoolExecutor executor) {
        // 获取队列中的任务数
        int queuedTasks = executor.getQueue().size();
        
        // 获取正在执行的任务数
        int runningTasks = executor.getActiveCount();
        
        // 估算单个任务对象的内存占用
        long taskObjectSize = estimateTaskObjectSize();
        
        // 计算任务对象总内存
        return (long) (queuedTasks + runningTasks) * taskObjectSize;
    }
    
    /**
     * 获取线程栈大小
     */
    private long getThreadStackSize() {
        // 尝试从JVM参数获取
        String stackSizeParam = System.getProperty("java.vm.info");
        
        // 默认栈大小（64位JVM通常为1MB）
        long defaultStackSize = 1024 * 1024; // 1MB
        
        // 尝试通过反射获取实际栈大小
        try {
            Field stackSizeField = Thread.class.getDeclaredField("stackSize");
            stackSizeField.setAccessible(true);
            Object stackSize = stackSizeField.get(null);
            if (stackSize instanceof Long) {
                return (Long) stackSize;
            }
        } catch (Exception e) {
            logger.warn("无法获取线程栈大小，使用默认值: {}", defaultStackSize);
        }
        
        return defaultStackSize;
    }
    
    /**
     * 估算单个任务的平均内存占用
     */
    private long estimateAverageTaskSize() {
        // 基于任务类型估算内存占用
        // 这里可以根据实际业务场景进行调整
        
        // Runnable任务的基本开销
        long baseTaskSize = 64; // 64字节
        
        // 任务参数的内存占用（估算）
        long parameterSize = 128; // 128字节
        
        // 任务执行上下文的内存占用
        long contextSize = 256; // 256字节
        
        return baseTaskSize + parameterSize + contextSize;
    }
    
    /**
     * 估算Thread对象的内存占用
     */
    private long estimateThreadObjectSize() {
        // Thread对象的基本大小
        long baseThreadSize = 200; // 200字节
        
        // ThreadLocal存储的开销
        long threadLocalSize = 100; // 100字节
        
        // 线程状态和属性信息
        long threadStateSize = 50; // 50字节
        
        return baseThreadSize + threadLocalSize + threadStateSize;
    }
    
    /**
     * 估算任务对象的内存占用
     */
    private long estimateTaskObjectSize() {
        // 任务对象的基本大小
        long baseTaskSize = 32; // 32字节
        
        // 任务参数和状态信息
        long taskStateSize = 64; // 64字节
        
        return baseTaskSize + taskStateSize;
    }
    
    /**
     * 计算内存使用率
     */
    private double calculateMemoryUsageRate(long totalMemory) {
        // 获取JVM总内存
        long totalJvmMemory = Runtime.getRuntime().totalMemory();
        
        // 计算使用率
        return (double) totalMemory / totalJvmMemory;
    }
}

// 线程池内存使用情况
public class ThreadPoolMemoryUsage {
    private long threadStackMemory;    // 线程栈内存
    private long taskQueueMemory;     // 任务队列内存
    private long threadObjectMemory;  // 线程对象内存
    private long taskObjectMemory;    // 任务对象内存
    private long totalMemory;         // 总内存占用
    private double memoryUsageRate;   // 内存使用率
    
    // getter/setter方法
}

// 任务内存分析器
@Component
public class TaskMemoryAnalyzer {
    
    private final MemoryProfiler memoryProfiler;
    private final TaskTracker taskTracker;
    
    /**
     * 分析单个任务的内存占用
     */
    public TaskMemoryAnalysis analyzeTaskMemory(Runnable task) {
        TaskMemoryAnalysis analysis = new TaskMemoryAnalysis();
        
        // 1. 分析任务对象本身的内存占用
        long taskObjectSize = analyzeTaskObjectSize(task);
        analysis.setTaskObjectSize(taskObjectSize);
        
        // 2. 分析任务执行时的内存占用
        long executionMemorySize = analyzeExecutionMemory(task);
        analysis.setExecutionMemorySize(executionMemorySize);
        
        // 3. 分析任务参数的内存占用
        long parameterMemorySize = analyzeParameterMemory(task);
        analysis.setParameterMemorySize(parameterMemorySize);
        
        // 4. 分析任务上下文的内存占用
        long contextMemorySize = analyzeContextMemory(task);
        analysis.setContextMemorySize(contextMemorySize);
        
        // 5. 计算总内存占用
        long totalMemorySize = taskObjectSize + executionMemorySize + 
                              parameterMemorySize + contextMemorySize;
        analysis.setTotalMemorySize(totalMemorySize);
        
        // 6. 分析内存占用模式
        MemoryPattern pattern = analyzeMemoryPattern(task);
        analysis.setMemoryPattern(pattern);
        
        return analysis;
    }
    
    /**
     * 分析任务对象本身的内存占用
     */
    private long analyzeTaskObjectSize(Runnable task) {
        // 使用Java Agent或反射分析对象大小
        try {
            // 获取对象的类信息
            Class<?> taskClass = task.getClass();
            
            // 分析字段大小
            long fieldSize = analyzeFieldSize(taskClass);
            
            // 分析方法大小
            long methodSize = analyzeMethodSize(taskClass);
            
            // 分析对象头大小
            long objectHeaderSize = analyzeObjectHeaderSize(taskClass);
            
            return fieldSize + methodSize + objectHeaderSize;
            
        } catch (Exception e) {
            logger.error("分析任务对象大小失败: {}", e.getMessage());
            return estimateTaskObjectSize(task);
        }
    }
    
    /**
     * 分析任务执行时的内存占用
     */
    private long analyzeExecutionMemory(Runnable task) {
        // 分析任务执行过程中创建的对象
        MemorySnapshot beforeSnapshot = memoryProfiler.takeSnapshot();
        
        try {
            // 执行任务
            task.run();
            
            // 获取执行后的内存快照
            MemorySnapshot afterSnapshot = memoryProfiler.takeSnapshot();
            
            // 计算内存差异
            return afterSnapshot.getUsedMemory() - beforeSnapshot.getUsedMemory();
            
        } catch (Exception e) {
            logger.error("分析任务执行内存失败: {}", e.getMessage());
            return 0;
        }
    }
    
    /**
     * 分析任务参数的内存占用
     */
    private long analyzeParameterMemory(Runnable task) {
        // 分析任务中引用的外部对象
        long parameterMemory = 0;
        
        // 使用反射获取任务的所有字段
        Field[] fields = task.getClass().getDeclaredFields();
        for (Field field : fields) {
            try {
                field.setAccessible(true);
                Object value = field.get(task);
                
                if (value != null) {
                    parameterMemory += estimateObjectSize(value);
                }
                
            } catch (Exception e) {
                logger.warn("分析字段内存失败: {}", e.getMessage());
            }
        }
        
        return parameterMemory;
    }
    
    /**
     * 分析任务上下文的内存占用
     */
    private long analyzeContextMemory(Runnable task) {
        // 分析ThreadLocal存储
        long threadLocalMemory = analyzeThreadLocalMemory();
        
        // 分析任务执行上下文
        long executionContextMemory = analyzeExecutionContextMemory();
        
        // 分析任务状态信息
        long taskStateMemory = analyzeTaskStateMemory();
        
        return threadLocalMemory + executionContextMemory + taskStateMemory;
    }
    
    /**
     * 分析内存占用模式
     */
    private MemoryPattern analyzeMemoryPattern(Runnable task) {
        MemoryPattern pattern = new MemoryPattern();
        
        // 分析内存分配模式
        AllocationPattern allocationPattern = analyzeAllocationPattern(task);
        pattern.setAllocationPattern(allocationPattern);
        
        // 分析内存释放模式
        DeallocationPattern deallocationPattern = analyzeDeallocationPattern(task);
        pattern.setDeallocationPattern(deallocationPattern);
        
        // 分析内存峰值
        long peakMemory = analyzePeakMemory(task);
        pattern.setPeakMemory(peakMemory);
        
        // 分析内存稳定性
        boolean memoryStable = analyzeMemoryStability(task);
        pattern.setMemoryStable(memoryStable);
        
        return pattern;
    }
    
    /**
     * 估算对象大小
     */
    private long estimateObjectSize(Object obj) {
        if (obj == null) {
            return 0;
        }
        
        Class<?> objClass = obj.getClass();
        
        // 基本类型的大小
        if (objClass.isPrimitive()) {
            return getPrimitiveSize(objClass);
        }
        
        // 数组的大小
        if (objClass.isArray()) {
            return estimateArraySize(obj);
        }
        
        // 对象的大小（估算）
        return estimateObjectSize(objClass);
    }
    
    /**
     * 获取基本类型的大小
     */
    private long getPrimitiveSize(Class<?> primitiveClass) {
        if (primitiveClass == boolean.class || primitiveClass == byte.class) {
            return 1;
        } else if (primitiveClass == char.class || primitiveClass == short.class) {
            return 2;
        } else if (primitiveClass == int.class || primitiveClass == float.class) {
            return 4;
        } else if (primitiveClass == long.class || primitiveClass == double.class) {
            return 8;
        }
        return 8; // 默认8字节
    }
    
    /**
     * 估算数组大小
     */
    private long estimateArraySize(Object array) {
        if (!array.getClass().isArray()) {
            return 0;
        }
        
        // 数组头大小
        long arrayHeaderSize = 16; // 对象头 + 长度字段
        
        // 数组元素大小
        Class<?> componentType = array.getClass().getComponentType();
        long elementSize = getPrimitiveSize(componentType);
        
        // 数组长度
        int arrayLength = Array.getLength(array);
        
        return arrayHeaderSize + (long) arrayLength * elementSize;
    }
}

// 任务内存分析结果
public class TaskMemoryAnalysis {
    private long taskObjectSize;      // 任务对象大小
    private long executionMemorySize;  // 执行时内存大小
    private long parameterMemorySize;  // 参数内存大小
    private long contextMemorySize;    // 上下文内存大小
    private long totalMemorySize;      // 总内存大小
    private MemoryPattern memoryPattern; // 内存模式
    
    // getter/setter方法
}

// 内存模式
public class MemoryPattern {
    private AllocationPattern allocationPattern;
    private DeallocationPattern deallocationPattern;
    private long peakMemory;
    private boolean memoryStable;
    
    // getter/setter方法
}

public enum AllocationPattern {
    LINEAR,      // 线性分配
    EXPONENTIAL, // 指数分配
    RANDOM,      // 随机分配
    BATCH        // 批量分配
}

public enum DeallocationPattern {
    IMMEDIATE,   // 立即释放
    DELAYED,     // 延迟释放
    BATCH,       // 批量释放
    GC_DEPENDENT // 依赖GC释放
}

// 线程池内存优化管理器
@Component
public class ThreadPoolMemoryOptimizer {
    
    @Autowired
    private ThreadPoolMemoryCalculator memoryCalculator;
    
    @Autowired
    private TaskMemoryAnalyzer taskAnalyzer;
    
    @Autowired
    private MemoryMonitor memoryMonitor;
    
    /**
     * 优化线程池内存使用
     */
    public MemoryOptimizationResult optimizeMemoryUsage(ThreadPoolExecutor executor) {
        try {
            // 1. 分析当前内存使用情况
            ThreadPoolMemoryUsage currentUsage = memoryCalculator.calculateTotalMemoryUsage(executor);
            
            // 2. 识别内存优化机会
            List<MemoryOptimizationOpportunity> opportunities = 
                identifyOptimizationOpportunities(currentUsage);
            
            // 3. 生成优化方案
            MemoryOptimizationPlan plan = generateOptimizationPlan(opportunities);
            
            // 4. 执行优化
            OptimizationResult result = executeOptimization(executor, plan);
            
            // 5. 验证优化效果
            ValidationResult validation = validateOptimizationEffect(executor, result);
            
            return new MemoryOptimizationResult(result.isSuccess(), result.getMessage(), validation);
            
        } catch (Exception e) {
            logger.error("线程池内存优化失败: {}", e.getMessage());
            return new MemoryOptimizationResult(false, "优化失败: " + e.getMessage(), null);
        }
    }
    
    /**
     * 识别内存优化机会
     */
    private List<MemoryOptimizationOpportunity> identifyOptimizationOpportunities(
            ThreadPoolMemoryUsage usage) {
        List<MemoryOptimizationOpportunity> opportunities = new ArrayList<>();
        
        // 线程栈内存优化机会
        if (usage.getThreadStackMemory() > usage.getTotalMemory() * 0.6) {
            opportunities.add(new MemoryOptimizationOpportunity(
                OptimizationType.THREAD_STACK_OPTIMIZATION,
                "线程栈内存占用过高",
                "建议减少线程栈大小或优化线程数量",
                OptimizationPriority.HIGH));
        }
        
        // 任务队列内存优化机会
        if (usage.getTaskQueueMemory() > usage.getTotalMemory() * 0.3) {
            opportunities.add(new MemoryOptimizationOpportunity(
                OptimizationType.TASK_QUEUE_OPTIMIZATION,
                "任务队列内存占用过高",
                "建议优化队列容量或使用更高效的队列类型",
                OptimizationPriority.MEDIUM));
        }
        
        // 线程对象内存优化机会
        if (usage.getThreadObjectMemory() > usage.getTotalMemory() * 0.2) {
            opportunities.add(new MemoryOptimizationOpportunity(
                OptimizationType.THREAD_OBJECT_OPTIMIZATION,
                "线程对象内存占用过高",
                "建议优化线程池配置或使用线程复用",
                OptimizationPriority.MEDIUM));
        }
        
        // 任务对象内存优化机会
        if (usage.getTaskObjectMemory() > usage.getTotalMemory() * 0.1) {
            opportunities.add(new MemoryOptimizationOpportunity(
                OptimizationType.TASK_OBJECT_OPTIMIZATION,
                "任务对象内存占用过高",
                "建议使用对象池或优化任务设计",
                OptimizationPriority.LOW));
        }
        
        return opportunities;
    }
    
    /**
     * 生成优化方案
     */
    private MemoryOptimizationPlan generateOptimizationPlan(
            List<MemoryOptimizationOpportunity> opportunities) {
        MemoryOptimizationPlan plan = new MemoryOptimizationPlan();
        
        // 按优先级排序
        opportunities.sort((o1, o2) -> o2.getPriority().compareTo(o1.getPriority()));
        
        for (MemoryOptimizationOpportunity opportunity : opportunities) {
            switch (opportunity.getType()) {
                case THREAD_STACK_OPTIMIZATION:
                    plan.addAction(createThreadStackOptimizationAction(opportunity));
                    break;
                case TASK_QUEUE_OPTIMIZATION:
                    plan.addAction(createTaskQueueOptimizationAction(opportunity));
                    break;
                case THREAD_OBJECT_OPTIMIZATION:
                    plan.addAction(createThreadObjectOptimizationAction(opportunity));
                    break;
                case TASK_OBJECT_OPTIMIZATION:
                    plan.addAction(createTaskObjectOptimizationAction(opportunity));
                    break;
            }
        }
        
        return plan;
    }
    
    /**
     * 创建线程栈优化动作
     */
    private OptimizationAction createThreadStackOptimizationAction(
            MemoryOptimizationOpportunity opportunity) {
        OptimizationAction action = new OptimizationAction();
        action.setType(ActionType.THREAD_STACK_OPTIMIZATION);
        action.setDescription("优化线程栈大小");
        
        // 配置参数
        action.addParameter("stack_size", "512KB"); // 减少栈大小
        action.addParameter("max_threads", "10");   // 限制最大线程数
        action.addParameter("core_threads", "5");    // 设置核心线程数
        
        return action;
    }
    
    /**
     * 创建任务队列优化动作
     */
    private OptimizationAction createTaskQueueOptimizationAction(
            MemoryOptimizationOpportunity opportunity) {
        OptimizationAction action = new OptimizationAction();
        action.setType(ActionType.TASK_QUEUE_OPTIMIZATION);
        action.setDescription("优化任务队列");
        
        // 配置参数
        action.addParameter("queue_type", "SynchronousQueue"); // 使用同步队列
        action.addParameter("queue_capacity", "0");            // 无容量限制
        action.addParameter("rejection_policy", "CallerRunsPolicy"); // 拒绝策略
        
        return action;
    }
    
    /**
     * 执行优化
     */
    private OptimizationResult executeOptimization(ThreadPoolExecutor executor, 
                                                 MemoryOptimizationPlan plan) {
        try {
            List<OptimizationResult> results = new ArrayList<>();
            
            for (OptimizationAction action : plan.getActions()) {
                OptimizationResult result = executeOptimizationAction(executor, action);
                results.add(result);
                
                if (!result.isSuccess()) {
                    return new OptimizationResult(false, "优化动作执行失败: " + result.getMessage());
                }
            }
            
            return new OptimizationResult(true, "优化执行成功");
            
        } catch (Exception e) {
            logger.error("优化执行失败: {}", e.getMessage());
            return new OptimizationResult(false, "优化执行失败: " + e.getMessage());
        }
    }
    
    /**
     * 执行优化动作
     */
    private OptimizationResult executeOptimizationAction(ThreadPoolExecutor executor, 
                                                        OptimizationAction action) {
        try {
            switch (action.getType()) {
                case THREAD_STACK_OPTIMIZATION:
                    return executeThreadStackOptimization(executor, action);
                case TASK_QUEUE_OPTIMIZATION:
                    return executeTaskQueueOptimization(executor, action);
                case THREAD_OBJECT_OPTIMIZATION:
                    return executeThreadObjectOptimization(executor, action);
                case TASK_OBJECT_OPTIMIZATION:
                    return executeTaskObjectOptimization(executor, action);
                default:
                    return new OptimizationResult(false, "不支持的优化动作类型");
            }
            
        } catch (Exception e) {
            logger.error("优化动作执行失败: {}", e.getMessage());
            return new OptimizationResult(false, "优化动作执行失败: " + e.getMessage());
        }
    }
    
    /**
     * 执行线程栈优化
     */
    private OptimizationResult executeThreadStackOptimization(ThreadPoolExecutor executor, 
                                                            OptimizationAction action) {
        try {
            // 获取当前线程池配置
            int currentCorePoolSize = executor.getCorePoolSize();
            int currentMaximumPoolSize = executor.getMaximumPoolSize();
            
            // 应用新的配置
            int newCorePoolSize = Integer.parseInt(action.getParameter("core_threads"));
            int newMaximumPoolSize = Integer.parseInt(action.getParameter("max_threads"));
            
            // 调整线程池大小
            executor.setCorePoolSize(newCorePoolSize);
            executor.setMaximumPoolSize(newMaximumPoolSize);
            
            // 记录配置变更
            logger.info("线程池配置已调整: core={}, max={}", newCorePoolSize, newMaximumPoolSize);
            
            return new OptimizationResult(true, "线程栈优化执行成功");
            
        } catch (Exception e) {
            logger.error("线程栈优化执行失败: {}", e.getMessage());
            return new OptimizationResult(false, "线程栈优化执行失败: " + e.getMessage());
        }
    }
    
    /**
     * 执行任务队列优化
     */
    private OptimizationResult executeTaskQueueOptimization(ThreadPoolExecutor executor, 
                                                           OptimizationAction action) {
        try {
            // 注意：ThreadPoolExecutor的队列类型在创建后不能修改
            // 这里只能提供建议或创建新的线程池
            
            String queueType = action.getParameter("queue_type");
            String rejectionPolicy = action.getParameter("rejection_policy");
            
            // 记录优化建议
            logger.info("建议使用队列类型: {}, 拒绝策略: {}", queueType, rejectionPolicy);
            
            return new OptimizationResult(true, "任务队列优化建议已记录");
            
        } catch (Exception e) {
            logger.error("任务队列优化执行失败: {}", e.getMessage());
            return new OptimizationResult(false, "任务队列优化执行失败: " + e.getMessage());
        }
    }
}

// 内存优化机会
public class MemoryOptimizationOpportunity {
    private OptimizationType type;
    private String title;
    private String description;
    private OptimizationPriority priority;
    
    // 构造函数和getter/setter方法
}

public enum OptimizationType {
    THREAD_STACK_OPTIMIZATION,
    TASK_QUEUE_OPTIMIZATION,
    THREAD_OBJECT_OPTIMIZATION,
    TASK_OBJECT_OPTIMIZATION
}

public enum OptimizationPriority {
    LOW,    // 低优先级
    MEDIUM, // 中优先级
    HIGH    // 高优先级
}

// 优化方案
public class MemoryOptimizationPlan {
    private List<OptimizationAction> actions = new ArrayList<>();
    
    public void addAction(OptimizationAction action) {
        actions.add(action);
    }
    
    // getter/setter方法
}

// 优化动作
public class OptimizationAction {
    private ActionType type;
    private String description;
    private Map<String, String> parameters = new HashMap<>();
    
    public void addParameter(String key, String value) {
        parameters.put(key, value);
    }
    
    public String getParameter(String key) {
        return parameters.get(key);
    }
    
    // getter/setter方法
}

public enum ActionType {
    THREAD_STACK_OPTIMIZATION,
    TASK_QUEUE_OPTIMIZATION,
    THREAD_OBJECT_OPTIMIZATION,
    TASK_OBJECT_OPTIMIZATION
}

// 线程池资源管控器
@Component
public class ThreadPoolResourceController {
    
    @Autowired
    private MemoryMonitor memoryMonitor;
    
    @Autowired
    private ThreadPoolRegistry threadPoolRegistry;
    
    /**
     * 控制线程池资源使用
     */
    public ResourceControlResult controlResourceUsage(ThreadPoolExecutor executor) {
        try {
            // 1. 监控资源使用情况
            ResourceUsage usage = monitorResourceUsage(executor);
            
            // 2. 检查资源限制
            List<ResourceLimit> limits = checkResourceLimits(usage);
            
            // 3. 执行资源控制
            ControlResult result = executeResourceControl(executor, limits);
            
            // 4. 记录控制日志
            logResourceControl(executor, result);
            
            return new ResourceControlResult(result.isSuccess(), result.getMessage());
            
        } catch (Exception e) {
            logger.error("资源控制失败: {}", e.getMessage());
            return new ResourceControlResult(false, "资源控制失败: " + e.getMessage());
        }
    }
    
    /**
     * 监控资源使用情况
     */
    private ResourceUsage monitorResourceUsage(ThreadPoolExecutor executor) {
        ResourceUsage usage = new ResourceUsage();
        
        // 监控内存使用
        long memoryUsage = getMemoryUsage(executor);
        usage.setMemoryUsage(memoryUsage);
        
        // 监控线程数量
        int threadCount = executor.getPoolSize();
        usage.setThreadCount(threadCount);
        
        // 监控任务队列大小
        int queueSize = executor.getQueue().size();
        usage.setQueueSize(queueSize);
        
        // 监控CPU使用率
        double cpuUsage = getCpuUsage(executor);
        usage.setCpuUsage(cpuUsage);
        
        return usage;
    }
    
    /**
     * 检查资源限制
     */
    private List<ResourceLimit> checkResourceLimits(ResourceUsage usage) {
        List<ResourceLimit> limits = new ArrayList<>();
        
        // 检查内存限制
        if (usage.getMemoryUsage() > getMaxMemoryLimit()) {
            limits.add(new ResourceLimit(
                LimitType.MEMORY_LIMIT,
                "内存使用超过限制",
                usage.getMemoryUsage(),
                getMaxMemoryLimit()));
        }
        
        // 检查线程数量限制
        if (usage.getThreadCount() > getMaxThreadLimit()) {
            limits.add(new ResourceLimit(
                LimitType.THREAD_LIMIT,
                "线程数量超过限制",
                usage.getThreadCount(),
                getMaxThreadLimit()));
        }
        
        // 检查队列大小限制
        if (usage.getQueueSize() > getMaxQueueLimit()) {
            limits.add(new ResourceLimit(
                LimitType.QUEUE_LIMIT,
                "队列大小超过限制",
                usage.getQueueSize(),
                getMaxQueueLimit()));
        }
        
        // 检查CPU使用率限制
        if (usage.getCpuUsage() > getMaxCpuLimit()) {
            limits.add(new ResourceLimit(
                LimitType.CPU_LIMIT,
                "CPU使用率超过限制",
                usage.getCpuUsage(),
                getMaxCpuLimit()));
        }
        
        return limits;
    }
    
    /**
     * 执行资源控制
     */
    private ControlResult executeResourceControl(ThreadPoolExecutor executor, 
                                               List<ResourceLimit> limits) {
        try {
            for (ResourceLimit limit : limits) {
                switch (limit.getType()) {
                    case MEMORY_LIMIT:
                        executeMemoryControl(executor, limit);
                        break;
                    case THREAD_LIMIT:
                        executeThreadControl(executor, limit);
                        break;
                    case QUEUE_LIMIT:
                        executeQueueControl(executor, limit);
                        break;
                    case CPU_LIMIT:
                        executeCpuControl(executor, limit);
                        break;
                }
            }
            
            return new ControlResult(true, "资源控制执行成功");
            
        } catch (Exception e) {
            logger.error("资源控制执行失败: {}", e.getMessage());
            return new ControlResult(false, "资源控制执行失败: " + e.getMessage());
        }
    }
    
    /**
     * 执行内存控制
     */
    private void executeMemoryControl(ThreadPoolExecutor executor, ResourceLimit limit) {
        // 减少线程池大小
        int currentCorePoolSize = executor.getCorePoolSize();
        int currentMaximumPoolSize = executor.getMaximumPoolSize();
        
        // 计算新的线程池大小
        int newCorePoolSize = Math.max(1, currentCorePoolSize / 2);
        int newMaximumPoolSize = Math.max(1, currentMaximumPoolSize / 2);
        
        // 应用新的配置
        executor.setCorePoolSize(newCorePoolSize);
        executor.setMaximumPoolSize(newMaximumPoolSize);
        
        logger.warn("内存使用超过限制，线程池大小已调整: core={}, max={}", 
                   newCorePoolSize, newMaximumPoolSize);
    }
    
    /**
     * 执行线程控制
     */
    private void executeThreadControl(ThreadPoolExecutor executor, ResourceLimit limit) {
        // 减少最大线程数
        int currentMaximumPoolSize = executor.getMaximumPoolSize();
        int newMaximumPoolSize = Math.max(1, currentMaximumPoolSize - 2);
        
        executor.setMaximumPoolSize(newMaximumPoolSize);
        
        logger.warn("线程数量超过限制，最大线程数已调整为: {}", newMaximumPoolSize);
    }
    
    /**
     * 执行队列控制
     */
    private void executeQueueControl(ThreadPoolExecutor executor, ResourceLimit limit) {
        // 清空部分队列任务
        BlockingQueue<Runnable> queue = executor.getQueue();
        int queueSize = queue.size();
        
        // 移除一半的任务
        int tasksToRemove = queueSize / 2;
        for (int i = 0; i < tasksToRemove; i++) {
            Runnable task = queue.poll();
            if (task != null) {
                logger.warn("队列大小超过限制，任务已移除: {}", task.getClass().getSimpleName());
            }
        }
    }
    
    /**
     * 执行CPU控制
     */
    private void executeCpuControl(ThreadPoolExecutor executor, ResourceLimit limit) {
        // 减少线程池大小以降低CPU使用率
        int currentCorePoolSize = executor.getCorePoolSize();
        int currentMaximumPoolSize = executor.getMaximumPoolSize();
        
        int newCorePoolSize = Math.max(1, currentCorePoolSize - 1);
        int newMaximumPoolSize = Math.max(1, currentMaximumPoolSize - 1);
        
        executor.setCorePoolSize(newCorePoolSize);
        executor.setMaximumPoolSize(newMaximumPoolSize);
        
        logger.warn("CPU使用率超过限制，线程池大小已调整: core={}, max={}", 
                   newCorePoolSize, newMaximumPoolSize);
    }
    
    /**
     * 获取内存使用量
     */
    private long getMemoryUsage(ThreadPoolExecutor executor) {
        // 使用内存监控器获取线程池的内存使用量
        return memoryMonitor.getThreadPoolMemoryUsage(executor);
    }
    
    /**
     * 获取CPU使用率
     */
    private double getCpuUsage(ThreadPoolExecutor executor) {
        // 使用系统监控器获取CPU使用率
        return SystemMonitor.getCpuUsage();
    }
    
    /**
     * 获取最大内存限制
     */
    private long getMaxMemoryLimit() {
        // 从配置中获取最大内存限制
        return 100 * 1024 * 1024; // 100MB
    }
    
    /**
     * 获取最大线程限制
     */
    private int getMaxThreadLimit() {
        // 从配置中获取最大线程限制
        return 20;
    }
    
    /**
     * 获取最大队列限制
     */
    private int getMaxQueueLimit() {
        // 从配置中获取最大队列限制
        return 1000;
    }
    
    /**
     * 获取最大CPU限制
     */
    private double getMaxCpuLimit() {
        // 从配置中获取最大CPU限制
        return 80.0; // 80%
    }
}

// 资源使用情况
public class ResourceUsage {
    private long memoryUsage;
    private int threadCount;
    private int queueSize;
    private double cpuUsage;
    
    // getter/setter方法
}

// 资源限制
public class ResourceLimit {
    private LimitType type;
    private String description;
    private double currentValue;
    private double limitValue;
    
    // 构造函数和getter/setter方法
}

public enum LimitType {
    MEMORY_LIMIT,
    THREAD_LIMIT,
    QUEUE_LIMIT,
    CPU_LIMIT
}

// 控制结果
public class ControlResult {
    private boolean success;
    private String message;
    
    // 构造函数和getter/setter方法
}

// 线程池性能监控器
@Component
public class ThreadPoolPerformanceMonitor {
    
    @Autowired
    private MetricsCollector metricsCollector;
    
    @Autowired
    private PerformanceAnalyzer performanceAnalyzer;
    
    /**
     * 监控线程池性能
     */
    public ThreadPoolPerformanceReport monitorPerformance(ThreadPoolExecutor executor) {
        try {
            // 1. 收集性能指标
            ThreadPoolMetrics metrics = collectPerformanceMetrics(executor);
            
            // 2. 分析性能瓶颈
            List<PerformanceBottleneck> bottlenecks = analyzePerformanceBottlenecks(metrics);
            
            // 3. 生成性能报告
            ThreadPoolPerformanceReport report = generatePerformanceReport(metrics, bottlenecks);
            
            // 4. 提供优化建议
            List<OptimizationSuggestion> suggestions = generateOptimizationSuggestions(bottlenecks);
            report.setOptimizationSuggestions(suggestions);
            
            return report;
            
        } catch (Exception e) {
            logger.error("线程池性能监控失败: {}", e.getMessage());
            return new ThreadPoolPerformanceReport(false, "监控失败: " + e.getMessage());
        }
    }
    
    /**
     * 收集性能指标
     */
    private ThreadPoolMetrics collectPerformanceMetrics(ThreadPoolExecutor executor) {
        ThreadPoolMetrics metrics = new ThreadPoolMetrics();
        
        // 收集线程池基本指标
        BasicMetrics basicMetrics = collectBasicMetrics(executor);
        metrics.setBasicMetrics(basicMetrics);
        
        // 收集内存使用指标
        MemoryMetrics memoryMetrics = collectMemoryMetrics(executor);
        metrics.setMemoryMetrics(memoryMetrics);
        
        // 收集任务执行指标
        TaskExecutionMetrics taskMetrics = collectTaskExecutionMetrics(executor);
        metrics.setTaskExecutionMetrics(taskMetrics);
        
        // 收集并发性能指标
        ConcurrencyMetrics concurrencyMetrics = collectConcurrencyMetrics(executor);
        metrics.setConcurrencyMetrics(concurrencyMetrics);
        
        return metrics;
    }
    
    /**
     * 收集基本指标
     */
    private BasicMetrics collectBasicMetrics(ThreadPoolExecutor executor) {
        BasicMetrics metrics = new BasicMetrics();
        
        // 线程池大小
        metrics.setCorePoolSize(executor.getCorePoolSize());
        metrics.setMaximumPoolSize(executor.getMaximumPoolSize());
        metrics.setCurrentPoolSize(executor.getPoolSize());
        metrics.setActiveThreadCount(executor.getActiveCount());
        
        // 任务队列
        metrics.setQueueSize(executor.getQueue().size());
        metrics.setQueueCapacity(getQueueCapacity(executor));
        
        // 任务统计
        metrics.setCompletedTaskCount(executor.getCompletedTaskCount());
        metrics.setTotalTaskCount(executor.getTaskCount());
        
        return metrics;
    }
    
    /**
     * 收集内存使用指标
     */
    private MemoryMetrics collectMemoryMetrics(ThreadPoolExecutor executor) {
        MemoryMetrics metrics = new MemoryMetrics();
        
        // 线程栈内存
        long threadStackMemory = calculateThreadStackMemory(executor);
        metrics.setThreadStackMemory(threadStackMemory);
        
        // 任务队列内存
        long taskQueueMemory = calculateTaskQueueMemory(executor);
        metrics.setTaskQueueMemory(taskQueueMemory);
        
        // 线程对象内存
        long threadObjectMemory = calculateThreadObjectMemory(executor);
        metrics.setThreadObjectMemory(threadObjectMemory);
        
        // 总内存使用
        long totalMemory = threadStackMemory + taskQueueMemory + threadObjectMemory;
        metrics.setTotalMemory(totalMemory);
        
        return metrics;
    }
    
    /**
     * 收集任务执行指标
     */
    private TaskExecutionMetrics collectTaskExecutionMetrics(ThreadPoolExecutor executor) {
        TaskExecutionMetrics metrics = new TaskExecutionMetrics();
        
        // 任务执行时间
        long averageExecutionTime = calculateAverageExecutionTime(executor);
        metrics.setAverageExecutionTime(averageExecutionTime);
        
        // 任务吞吐量
        double throughput = calculateThroughput(executor);
        metrics.setThroughput(throughput);
        
        // 任务成功率
        double successRate = calculateSuccessRate(executor);
        metrics.setSuccessRate(successRate);
        
        // 任务等待时间
        long averageWaitTime = calculateAverageWaitTime(executor);
        metrics.setAverageWaitTime(averageWaitTime);
        
        return metrics;
    }
    
    /**
     * 收集并发性能指标
     */
    private ConcurrencyMetrics collectConcurrencyMetrics(ThreadPoolExecutor executor) {
        ConcurrencyMetrics metrics = new ConcurrencyMetrics();
        
        // 并发度
        double concurrency = calculateConcurrency(executor);
        metrics.setConcurrency(concurrency);
        
        // 资源利用率
        double resourceUtilization = calculateResourceUtilization(executor);
        metrics.setResourceUtilization(resourceUtilization);
        
        // 锁竞争情况
        LockContentionMetrics lockContention = calculateLockContention(executor);
        metrics.setLockContention(lockContention);
        
        return metrics;
    }
    
    /**
     * 分析性能瓶颈
     */
    private List<PerformanceBottleneck> analyzePerformanceBottlenecks(ThreadPoolMetrics metrics) {
        List<PerformanceBottleneck> bottlenecks = new ArrayList<>();
        
        // 内存使用瓶颈
        if (metrics.getMemoryMetrics().getTotalMemory() > 50 * 1024 * 1024) { // 50MB
            bottlenecks.add(new PerformanceBottleneck(
                BottleneckType.HIGH_MEMORY_USAGE,
                "内存使用过高",
                metrics.getMemoryMetrics().getTotalMemory()));
        }
        
        // 任务执行时间瓶颈
        if (metrics.getTaskExecutionMetrics().getAverageExecutionTime() > 5000) { // 5秒
            bottlenecks.add(new PerformanceBottleneck(
                BottleneckType.LONG_EXECUTION_TIME,
                "任务执行时间过长",
                metrics.getTaskExecutionMetrics().getAverageExecutionTime()));
        }
        
        // 任务等待时间瓶颈
        if (metrics.getTaskExecutionMetrics().getAverageWaitTime() > 1000) { // 1秒
            bottlenecks.add(new PerformanceBottleneck(
                BottleneckType.LONG_WAIT_TIME,
                "任务等待时间过长",
                metrics.getTaskExecutionMetrics().getAverageWaitTime()));
        }
        
        // 资源利用率瓶颈
        if (metrics.getConcurrencyMetrics().getResourceUtilization() < 0.5) {
            bottlenecks.add(new PerformanceBottleneck(
                BottleneckType.LOW_RESOURCE_UTILIZATION,
                "资源利用率过低",
                metrics.getConcurrencyMetrics().getResourceUtilization()));
        }
        
        return bottlenecks;
    }
    
    /**
     * 生成性能报告
     */
    private ThreadPoolPerformanceReport generatePerformanceReport(ThreadPoolMetrics metrics, 
                                                               List<PerformanceBottleneck> bottlenecks) {
        ThreadPoolPerformanceReport report = new ThreadPoolPerformanceReport();
        
        // 设置基本信息
        report.setGeneratedAt(System.currentTimeMillis());
        report.setMetrics(metrics);
        report.setBottlenecks(bottlenecks);
        
        // 计算性能评分
        double performanceScore = calculatePerformanceScore(metrics, bottlenecks);
        report.setPerformanceScore(performanceScore);
        
        // 设置性能等级
        PerformanceLevel level = determinePerformanceLevel(performanceScore);
        report.setPerformanceLevel(level);
        
        // 生成总结
        String summary = generatePerformanceSummary(metrics, bottlenecks);
        report.setSummary(summary);
        
        return report;
    }
    
    /**
     * 计算性能评分
     */
    private double calculatePerformanceScore(ThreadPoolMetrics metrics, List<PerformanceBottleneck> bottlenecks) {
        double score = 100.0;
        
        // 内存使用评分
        long totalMemory = metrics.getMemoryMetrics().getTotalMemory();
        if (totalMemory > 100 * 1024 * 1024) { // 100MB
            score -= 30;
        } else if (totalMemory > 50 * 1024 * 1024) { // 50MB
            score -= 20;
        } else if (totalMemory > 20 * 1024 * 1024) { // 20MB
            score -= 10;
        }
        
        // 任务执行时间评分
        long executionTime = metrics.getTaskExecutionMetrics().getAverageExecutionTime();
        if (executionTime > 10000) { // 10秒
            score -= 25;
        } else if (executionTime > 5000) { // 5秒
            score -= 15;
        } else if (executionTime > 1000) { // 1秒
            score -= 10;
        }
        
        // 任务等待时间评分
        long waitTime = metrics.getTaskExecutionMetrics().getAverageWaitTime();
        if (waitTime > 5000) { // 5秒
            score -= 20;
        } else if (waitTime > 1000) { // 1秒
            score -= 15;
        } else if (waitTime > 500) { // 500ms
            score -= 10;
        }
        
        // 资源利用率评分
        double utilization = metrics.getConcurrencyMetrics().getResourceUtilization();
        if (utilization < 0.3) {
            score -= 25;
        } else if (utilization < 0.5) {
            score -= 15;
        } else if (utilization < 0.7) {
            score -= 10;
        }
        
        // 瓶颈数量评分
        score -= bottlenecks.size() * 5;
        
        return Math.max(0, score);
    }
}

// 线程池性能指标
public class ThreadPoolMetrics {
    private BasicMetrics basicMetrics;
    private MemoryMetrics memoryMetrics;
    private TaskExecutionMetrics taskExecutionMetrics;
    private ConcurrencyMetrics concurrencyMetrics;
    
    // getter/setter方法
}

// 基本指标
public class BasicMetrics {
    private int corePoolSize;
    private int maximumPoolSize;
    private int currentPoolSize;
    private int activeThreadCount;
    private int queueSize;
    private int queueCapacity;
    private long completedTaskCount;
    private long totalTaskCount;
    
    // getter/setter方法
}

// 内存指标
public class MemoryMetrics {
    private long threadStackMemory;
    private long taskQueueMemory;
    private long threadObjectMemory;
    private long totalMemory;
    
    // getter/setter方法
}

// 任务执行指标
public class TaskExecutionMetrics {
    private long averageExecutionTime;
    private double throughput;
    private double successRate;
    private long averageWaitTime;
    
    // getter/setter方法
}

// 并发性能指标
public class ConcurrencyMetrics {
    private double concurrency;
    private double resourceUtilization;
    private LockContentionMetrics lockContention;
    
    // getter/setter方法
}

// 线程池性能报告
public class ThreadPoolPerformanceReport {
    private boolean success;
    private String message;
    private long generatedAt;
    private ThreadPoolMetrics metrics;
    private List<PerformanceBottleneck> bottlenecks;
    private double performanceScore;
    private PerformanceLevel performanceLevel;
    private String summary;
    private List<OptimizationSuggestion> optimizationSuggestions;
    
    // getter/setter方法
}