第81集Java线程池原理与性能调优实战

/**
 * Java线程池配置类
 */
@Configuration
public class JavaThreadPoolConfig {
    
    @Value("${thread-pool.core-pool-size:10}")
    private int corePoolSize;
    
    @Value("${thread-pool.max-pool-size:50}")
    private int maxPoolSize;
    
    @Value("${thread-pool.queue-capacity:1000}")
    private int queueCapacity;
    
    /**
     * Java线程池配置属性
     */
    @Bean
    public ThreadPoolProperties threadPoolProperties() {
        return ThreadPoolProperties.builder()
            .corePoolSize(corePoolSize)
            .maxPoolSize(maxPoolSize)
            .queueCapacity(queueCapacity)
            .build();
    }
    
    /**
     * 线程池管理器
     */
    @Bean
    public ThreadPoolManager threadPoolManager() {
        return new ThreadPoolManager(threadPoolProperties());
    }
    
    /**
     * 线程池监控器
     */
    @Bean
    public ThreadPoolMonitor threadPoolMonitor() {
        return new ThreadPoolMonitor(threadPoolProperties());
    }
    
    /**
     * 线程池性能分析器
     */
    @Bean
    public ThreadPoolPerformanceAnalyzer performanceAnalyzer() {
        return new ThreadPoolPerformanceAnalyzer(threadPoolProperties());
    }
}

/**
 * 线程池配置属性
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ThreadPoolProperties {
    private int corePoolSize;
    private int maxPoolSize;
    private int queueCapacity;
    
    // 线程池配置
    private long keepAliveTime = 60; // 秒
    private String threadNamePrefix = "ThreadPool-";
    private boolean allowCoreThreadTimeOut = false;
    private String rejectedExecutionHandler = "CallerRunsPolicy";
    
    // 线程池类型配置
    private String threadPoolType = "ThreadPoolExecutor";
    private boolean enableScheduledPool = true;
    private boolean enableForkJoinPool = true;
    
    // 监控配置
    private boolean enableMonitoring = true;
    private int monitoringInterval = 60; // 秒
    private boolean enableMetrics = true;
    
    // 性能配置
    private boolean enablePerformanceOptimization = true;
    private int maxConcurrentTasks = 1000;
    private boolean enableDynamicScaling = true;
}

/**
 * 线程池原理服务
 */
@Service
public class ThreadPoolPrincipleService {
    
    private final ThreadPoolProperties properties;
    private final Map<String, ExecutorService> threadPools = new ConcurrentHashMap<>();
    
    public ThreadPoolPrincipleService(ThreadPoolProperties properties) {
        this.properties = properties;
    }
    
    /**
     * 创建ThreadPoolExecutor
     * @param poolName 线程池名称
     * @return ThreadPoolExecutor
     */
    public ThreadPoolExecutor createThreadPoolExecutor(String poolName) {
        ThreadFactory threadFactory = new CustomThreadFactory(poolName + "-");
        
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            properties.getCorePoolSize(),
            properties.getMaxPoolSize(),
            properties.getKeepAliveTime(),
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(properties.getQueueCapacity()),
            threadFactory,
            createRejectedExecutionHandler(properties.getRejectedExecutionHandler())
        );
        
        executor.allowCoreThreadTimeOut(properties.isAllowCoreThreadTimeOut());
        
        return executor;
    }
    
    /**
     * 创建ScheduledThreadPoolExecutor
     * @param poolName 线程池名称
     * @return ScheduledThreadPoolExecutor
     */
    public ScheduledThreadPoolExecutor createScheduledThreadPoolExecutor(String poolName) {
        ThreadFactory threadFactory = new CustomThreadFactory(poolName + "-scheduled-");
        
        return new ScheduledThreadPoolExecutor(
            properties.getCorePoolSize(),
            threadFactory,
            createRejectedExecutionHandler(properties.getRejectedExecutionHandler())
        );
    }
    
    /**
     * 创建ForkJoinPool
     * @param poolName 线程池名称
     * @return ForkJoinPool
     */
    public ForkJoinPool createForkJoinPool(String poolName) {
        ForkJoinPool.ForkJoinWorkerThreadFactory factory = new CustomForkJoinWorkerThreadFactory(poolName);
        
        return new ForkJoinPool(
            properties.getCorePoolSize(),
            factory,
            null,
            true
        );
    }
    
    /**
     * 创建拒绝执行处理器
     * @param handlerType 处理器类型
     * @return 拒绝执行处理器
     */
    private RejectedExecutionHandler createRejectedExecutionHandler(String handlerType) {
        switch (handlerType.toLowerCase()) {
            case "abortpolicy":
                return new ThreadPoolExecutor.AbortPolicy();
            case "callerrunspolicy":
                return new ThreadPoolExecutor.CallerRunsPolicy();
            case "discardpolicy":
                return new ThreadPoolExecutor.DiscardPolicy();
            case "discardoldestpolicy":
                return new ThreadPoolExecutor.DiscardOldestPolicy();
            case "custompolicy":
                return new CustomRejectedExecutionHandler();
            default:
                return new ThreadPoolExecutor.CallerRunsPolicy();
        }
    }
    
    /**
     * 执行任务
     * @param poolName 线程池名称
     * @param task 任务
     * @return Future
     */
    public Future<?> executeTask(String poolName, Runnable task) {
        ExecutorService executor = threadPools.computeIfAbsent(poolName, this::createThreadPoolExecutor);
        return executor.submit(task);
    }
    
    /**
     * 执行任务（带返回值）
     * @param poolName 线程池名称
     * @param task 任务
     * @param <T> 返回类型
     * @return Future
     */
    public <T> Future<T> executeTask(String poolName, Callable<T> task) {
        ExecutorService executor = threadPools.computeIfAbsent(poolName, this::createThreadPoolExecutor);
        return executor.submit(task);
    }
    
    /**
     * 延迟执行任务
     * @param poolName 线程池名称
     * @param task 任务
     * @param delay 延迟时间
     * @param unit 时间单位
     * @return ScheduledFuture
     */
    public ScheduledFuture<?> scheduleTask(String poolName, Runnable task, long delay, TimeUnit unit) {
        ScheduledExecutorService executor = (ScheduledExecutorService) threadPools.computeIfAbsent(
            poolName + "-scheduled", k -> createScheduledThreadPoolExecutor(poolName));
        return executor.schedule(task, delay, unit);
    }
    
    /**
     * 定时执行任务
     * @param poolName 线程池名称
     * @param task 任务
     * @param initialDelay 初始延迟
     * @param period 执行周期
     * @param unit 时间单位
     * @return ScheduledFuture
     */
    public ScheduledFuture<?> scheduleAtFixedRate(String poolName, Runnable task, 
                                                  long initialDelay, long period, TimeUnit unit) {
        ScheduledExecutorService executor = (ScheduledExecutorService) threadPools.computeIfAbsent(
            poolName + "-scheduled", k -> createScheduledThreadPoolExecutor(poolName));
        return executor.scheduleAtFixedRate(task, initialDelay, period, unit);
    }
    
    /**
     * 执行ForkJoin任务
     * @param poolName 线程池名称
     * @param task ForkJoin任务
     * @param <T> 返回类型
     * @return Future
     */
    public <T> Future<T> executeForkJoinTask(String poolName, ForkJoinTask<T> task) {
        ForkJoinPool pool = (ForkJoinPool) threadPools.computeIfAbsent(
            poolName + "-forkjoin", k -> createForkJoinPool(poolName));
        return pool.submit(task);
    }
    
    /**
     * 获取线程池状态
     * @param poolName 线程池名称
     * @return 线程池状态
     */
    public ThreadPoolStatus getThreadPoolStatus(String poolName) {
        ExecutorService executor = threadPools.get(poolName);
        if (executor instanceof ThreadPoolExecutor) {
            ThreadPoolExecutor tpe = (ThreadPoolExecutor) executor;
            
            return ThreadPoolStatus.builder()
                .poolName(poolName)
                .corePoolSize(tpe.getCorePoolSize())
                .maximumPoolSize(tpe.getMaximumPoolSize())
                .currentPoolSize(tpe.getPoolSize())
                .activeThreadCount(tpe.getActiveCount())
                .completedTaskCount(tpe.getCompletedTaskCount())
                .totalTaskCount(tpe.getTaskCount())
                .queueSize(tpe.getQueue().size())
                .isShutdown(tpe.isShutdown())
                .isTerminated(tpe.isTerminated())
                .build();
        }
        
        return ThreadPoolStatus.builder().poolName(poolName).build();
    }
}

/**
 * 自定义线程工厂
 */
public class CustomThreadFactory implements ThreadFactory {
    private final String namePrefix;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    
    public CustomThreadFactory(String namePrefix) {
        this.namePrefix = namePrefix;
        this.group = Thread.currentThread().getThreadGroup();
    }
    
    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
        
        if (thread.isDaemon()) {
            thread.setDaemon(false);
        }
        
        if (thread.getPriority() != Thread.NORM_PRIORITY) {
            thread.setPriority(Thread.NORM_PRIORITY);
        }
        
        return thread;
    }
}

/**
 * 自定义ForkJoin工作线程工厂
 */
public class CustomForkJoinWorkerThreadFactory implements ForkJoinPool.ForkJoinWorkerThreadFactory {
    private final String namePrefix;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    
    public CustomForkJoinWorkerThreadFactory(String namePrefix) {
        this.namePrefix = namePrefix;
    }
    
    @Override
    public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
        ForkJoinWorkerThread thread = new CustomForkJoinWorkerThread(pool);
        thread.setName(namePrefix + threadNumber.getAndIncrement());
        return thread;
    }
}

/**
 * 自定义ForkJoin工作线程
 */
public class CustomForkJoinWorkerThread extends ForkJoinWorkerThread {
    public CustomForkJoinWorkerThread(ForkJoinPool pool) {
        super(pool);
    }
}

/**
 * 自定义拒绝执行处理器
 */
public class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        log.warn("任务被拒绝执行: {}", r.toString());
        
        // 尝试重新提交到队列
        if (!executor.isShutdown()) {
            try {
                executor.getQueue().put(r);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                log.error("重新提交任务失败", e);
            }
        }
    }
}

/**
 * 线程池状态
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ThreadPoolStatus {
    private String poolName;
    private int corePoolSize;
    private int maximumPoolSize;
    private int currentPoolSize;
    private int activeThreadCount;
    private long completedTaskCount;
    private long totalTaskCount;
    private int queueSize;
    private boolean isShutdown;
    private boolean isTerminated;
}

/**
 * 线程池调优服务
 */
@Service
public class ThreadPoolTuningService {
    
    private final ThreadPoolProperties properties;
    private final ThreadPoolPrincipleService principleService;
    
    public ThreadPoolTuningService(ThreadPoolProperties properties) {
        this.properties = properties;
        this.principleService = null; // 注入
    }
    
    /**
     * 分析线程池性能
     * @param poolName 线程池名称
     * @return 性能分析结果
     */
    public ThreadPoolPerformanceAnalysis analyzePerformance(String poolName) {
        try {
            ThreadPoolStatus status = principleService.getThreadPoolStatus(poolName);
            
            // 计算性能指标
            double cpuUtilization = calculateCPUUtilization(status);
            double memoryUtilization = calculateMemoryUtilization(status);
            double throughput = calculateThroughput(status);
            double responseTime = calculateResponseTime(status);
            
            return ThreadPoolPerformanceAnalysis.builder()
                .poolName(poolName)
                .cpuUtilization(cpuUtilization)
                .memoryUtilization(memoryUtilization)
                .throughput(throughput)
                .responseTime(responseTime)
                .status(status)
                .build();
            
        } catch (Exception e) {
            log.error("分析线程池性能失败: poolName={}", poolName, e);
            return ThreadPoolPerformanceAnalysis.builder().poolName(poolName).build();
        }
    }
    
    /**
     * 计算CPU使用率
     * @param status 线程池状态
     * @return CPU使用率
     */
    private double calculateCPUUtilization(ThreadPoolStatus status) {
        if (status.getMaximumPoolSize() == 0) {
            return 0.0;
        }
        
        return (double) status.getActiveThreadCount() / status.getMaximumPoolSize();
    }
    
    /**
     * 计算内存使用率
     * @param status 线程池状态
     * @return 内存使用率
     */
    private double calculateMemoryUtilization(ThreadPoolStatus status) {
        if (status.getMaximumPoolSize() == 0) {
            return 0.0;
        }
        
        return (double) status.getCurrentPoolSize() / status.getMaximumPoolSize();
    }
    
    /**
     * 计算吞吐量
     * @param status 线程池状态
     * @return 吞吐量
     */
    private double calculateThroughput(ThreadPoolStatus status) {
        if (status.getTotalTaskCount() == 0) {
            return 0.0;
        }
        
        return (double) status.getCompletedTaskCount() / status.getTotalTaskCount();
    }
    
    /**
     * 计算响应时间
     * @param status 线程池状态
     * @return 响应时间
     */
    private double calculateResponseTime(ThreadPoolStatus status) {
        // 这里需要根据实际的任务执行时间来计算
        // 简化实现，返回一个模拟值
        return status.getQueueSize() * 10.0; // 毫秒
    }
    
    /**
     * 获取调优建议
     * @param poolName 线程池名称
     * @return 调优建议
     */
    public List<ThreadPoolTuningRecommendation> getTuningRecommendations(String poolName) {
        List<ThreadPoolTuningRecommendation> recommendations = new ArrayList<>();
        
        try {
            ThreadPoolPerformanceAnalysis analysis = analyzePerformance(poolName);
            ThreadPoolStatus status = analysis.getStatus();
            
            // 基于CPU使用率提供建议
            if (analysis.getCpuUtilization() > 0.8) {
                recommendations.add(new ThreadPoolTuningRecommendation(
                    "增加最大线程数",
                    "当前CPU使用率过高，建议增加最大线程数",
                    "HIGH"
                ));
            } else if (analysis.getCpuUtilization() < 0.3) {
                recommendations.add(new ThreadPoolTuningRecommendation(
                    "减少最大线程数",
                    "当前CPU使用率较低，建议减少最大线程数",
                    "MEDIUM"
                ));
            }
            
            // 基于内存使用率提供建议
            if (analysis.getMemoryUtilization() > 0.8) {
                recommendations.add(new ThreadPoolTuningRecommendation(
                    "增加队列容量",
                    "当前内存使用率过高，建议增加队列容量",
                    "HIGH"
                ));
            }
            
            // 基于队列大小提供建议
            if (status.getQueueSize() > status.getMaximumPoolSize()) {
                recommendations.add(new ThreadPoolTuningRecommendation(
                    "优化任务处理速度",
                    "当前队列积压严重，建议优化任务处理速度",
                    "HIGH"
                ));
            }
            
            // 基于吞吐量提供建议
            if (analysis.getThroughput() < 0.7) {
                recommendations.add(new ThreadPoolTuningRecommendation(
                    "优化任务执行效率",
                    "当前吞吐量较低，建议优化任务执行效率",
                    "MEDIUM"
                ));
            }
            
        } catch (Exception e) {
            log.error("获取调优建议失败: poolName={}", poolName, e);
        }
        
        return recommendations;
    }
    
    /**
     * 动态调整线程池参数
     * @param poolName 线程池名称
     * @param newCorePoolSize 新的核心线程数
     * @param newMaxPoolSize 新的最大线程数
     * @return 是否调整成功
     */
    public boolean adjustThreadPoolParameters(String poolName, int newCorePoolSize, int newMaxPoolSize) {
        try {
            ExecutorService executor = principleService.threadPools.get(poolName);
            if (executor instanceof ThreadPoolExecutor) {
                ThreadPoolExecutor tpe = (ThreadPoolExecutor) executor;
                
                // 调整核心线程数
                tpe.setCorePoolSize(newCorePoolSize);
                
                // 调整最大线程数
                tpe.setMaximumPoolSize(newMaxPoolSize);
                
                log.info("线程池参数调整成功: poolName={}, corePoolSize={}, maxPoolSize={}", 
                    poolName, newCorePoolSize, newMaxPoolSize);
                
                return true;
            }
            
        } catch (Exception e) {
            log.error("调整线程池参数失败: poolName={}", poolName, e);
        }
        
        return false;
    }
    
    /**
     * 预热线程池
     * @param poolName 线程池名称
     * @return 是否预热成功
     */
    public boolean warmupThreadPool(String poolName) {
        try {
            ExecutorService executor = principleService.threadPools.get(poolName);
            if (executor instanceof ThreadPoolExecutor) {
                ThreadPoolExecutor tpe = (ThreadPoolExecutor) executor;
                
                // 预热核心线程
                int corePoolSize = tpe.getCorePoolSize();
                for (int i = 0; i < corePoolSize; i++) {
                    tpe.prestartCoreThread();
                }
                
                log.info("线程池预热成功: poolName={}, corePoolSize={}", poolName, corePoolSize);
                
                return true;
            }
            
        } catch (Exception e) {
            log.error("线程池预热失败: poolName={}", poolName, e);
        }
        
        return false;
    }
}

/**
 * 线程池性能分析
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ThreadPoolPerformanceAnalysis {
    private String poolName;
    private double cpuUtilization;
    private double memoryUtilization;
    private double throughput;
    private double responseTime;
    private ThreadPoolStatus status;
}

/**
 * 线程池调优建议
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ThreadPoolTuningRecommendation {
    private String title;
    private String description;
    private String priority; // HIGH, MEDIUM, LOW
}

/**
 * 线程池监控器
 */
@Component
public class ThreadPoolMonitor {
    
    private final ThreadPoolProperties properties;
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
    private final List<ThreadPoolSnapshot> snapshots = new ArrayList<>();
    private final Map<String, ThreadPoolStats> statsMap = new ConcurrentHashMap<>();
    
    public ThreadPoolMonitor(ThreadPoolProperties properties) {
        this.properties = properties;
        if (properties.isEnableMonitoring()) {
            startMonitoring();
        }
    }
    
    /**
     * 开始监控
     */
    private void startMonitoring() {
        scheduler.scheduleAtFixedRate(
            this::takeSnapshot,
            0,
            properties.getMonitoringInterval(),
            TimeUnit.SECONDS
        );
    }
    
    /**
     * 获取快照
     */
    private void takeSnapshot() {
        try {
            ThreadPoolPrincipleService principleService = new ThreadPoolPrincipleService(properties);
            
            List<ThreadPoolStatus> statuses = new ArrayList<>();
            for (String poolName : principleService.threadPools.keySet()) {
                ThreadPoolStatus status = principleService.getThreadPoolStatus(poolName);
                statuses.add(status);
            }
            
            ThreadPoolSnapshot snapshot = ThreadPoolSnapshot.builder()
                .timestamp(System.currentTimeMillis())
                .statuses(statuses)
                .build();
            
            snapshots.add(snapshot);
            
            // 保持最近100个快照
            if (snapshots.size() > 100) {
                snapshots.remove(0);
            }
            
            // 更新统计信息
            updateStats(statuses);
            
        } catch (Exception e) {
            log.error("获取线程池快照失败", e);
        }
    }
    
    /**
     * 更新统计信息
     * @param statuses 线程池状态列表
     */
    private void updateStats(List<ThreadPoolStatus> statuses) {
        for (ThreadPoolStatus status : statuses) {
            String poolName = status.getPoolName();
            ThreadPoolStats stats = statsMap.computeIfAbsent(poolName, k -> new ThreadPoolStats());
            
            stats.setPoolName(poolName);
            stats.setLastUpdateTime(System.currentTimeMillis());
            stats.setTotalTasks(stats.getTotalTasks() + status.getTotalTaskCount());
            stats.setCompletedTasks(stats.getCompletedTasks() + status.getCompletedTaskCount());
            stats.setMaxActiveThreads(Math.max(stats.getMaxActiveThreads(), status.getActiveThreadCount()));
            stats.setMaxQueueSize(Math.max(stats.getMaxQueueSize(), status.getQueueSize()));
        }
    }
    
    /**
     * 获取监控报告
     * @return 监控报告
     */
    public ThreadPoolMonitorReport getMonitorReport() {
        try {
            if (snapshots.isEmpty()) {
                return ThreadPoolMonitorReport.builder().build();
            }
            
            ThreadPoolSnapshot latest = snapshots.get(snapshots.size() - 1);
            ThreadPoolSnapshot previous = snapshots.size() > 1 ? 
                snapshots.get(snapshots.size() - 2) : latest;
            
            // 计算趋势
            Map<String, Integer> trendMap = new HashMap<>();
            for (ThreadPoolStatus status : latest.getStatuses()) {
                String poolName = status.getPoolName();
                ThreadPoolStatus prevStatus = previous.getStatuses().stream()
                    .filter(s -> s.getPoolName().equals(poolName))
                    .findFirst()
                    .orElse(status);
                
                int trend = status.getActiveThreadCount() - prevStatus.getActiveThreadCount();
                trendMap.put(poolName, trend);
            }
            
            return ThreadPoolMonitorReport.builder()
                .currentSnapshot(latest)
                .trendMap(trendMap)
                .snapshotCount(snapshots.size())
                .statsMap(new HashMap<>(statsMap))
                .build();
            
        } catch (Exception e) {
            log.error("获取监控报告失败", e);
            return ThreadPoolMonitorReport.builder().build();
        }
    }
    
    /**
     * 获取告警
     * @return 告警列表
     */
    public List<ThreadPoolAlert> getAlerts() {
        List<ThreadPoolAlert> alerts = new ArrayList<>();
        
        try {
            ThreadPoolMonitorReport report = getMonitorReport();
            
            for (ThreadPoolStatus status : report.getCurrentSnapshot().getStatuses()) {
                // 检查活跃线程数
                if (status.getActiveThreadCount() > properties.getMaxConcurrentTasks()) {
                    alerts.add(new ThreadPoolAlert(
                        "活跃线程数过多",
                        "线程池 " + status.getPoolName() + " 活跃线程数超过限制",
                        "HIGH"
                    ));
                }
                
                // 检查队列大小
                if (status.getQueueSize() > status.getMaximumPoolSize()) {
                    alerts.add(new ThreadPoolAlert(
                        "队列积压严重",
                        "线程池 " + status.getPoolName() + " 队列积压严重",
                        "MEDIUM"
                    ));
                }
                
                // 检查线程池状态
                if (status.isShutdown()) {
                    alerts.add(new ThreadPoolAlert(
                        "线程池已关闭",
                        "线程池 " + status.getPoolName() + " 已关闭",
                        "HIGH"
                    ));
                }
            }
            
        } catch (Exception e) {
            log.error("获取告警失败", e);
        }
        
        return alerts;
    }
}

/**
 * 线程池快照
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ThreadPoolSnapshot {
    private long timestamp;
    private List<ThreadPoolStatus> statuses;
}

/**
 * 线程池统计信息
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ThreadPoolStats {
    private String poolName;
    private long lastUpdateTime;
    private long totalTasks;
    private long completedTasks;
    private int maxActiveThreads;
    private int maxQueueSize;
}

/**
 * 线程池监控报告
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ThreadPoolMonitorReport {
    private ThreadPoolSnapshot currentSnapshot;
    private Map<String, Integer> trendMap;
    private int snapshotCount;
    private Map<String, ThreadPoolStats> statsMap;
}

/**
 * 线程池告警
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ThreadPoolAlert {
    private String title;
    private String description;
    private String severity; // HIGH, MEDIUM, LOW
}

/**
 * 线程池性能分析器
 */
@Component
public class ThreadPoolPerformanceAnalyzer {
    
    private final ThreadPoolProperties properties;
    private final ThreadPoolMonitor monitor;
    
    public ThreadPoolPerformanceAnalyzer(ThreadPoolProperties properties) {
        this.properties = properties;
        this.monitor = null; // 注入
    }
    
    /**
     * 分析线程池性能
     * @return 性能分析报告
     */
    public ThreadPoolPerformanceReport analyzePerformance() {
        try {
            ThreadPoolMonitorReport monitorReport = monitor.getMonitorReport();
            List<ThreadPoolAlert> alerts = monitor.getAlerts();
            
            // 计算性能指标
            Map<String, ThreadPoolPerformanceMetrics> metricsMap = calculatePerformanceMetrics(monitorReport);
            
            // 生成优化建议
            List<ThreadPoolOptimizationRecommendation> recommendations = generateOptimizationRecommendations(metricsMap, alerts);
            
            return ThreadPoolPerformanceReport.builder()
                .metricsMap(metricsMap)
                .alerts(alerts)
                .recommendations(recommendations)
                .analysisTime(System.currentTimeMillis())
                .build();
            
        } catch (Exception e) {
            log.error("分析线程池性能失败", e);
            return ThreadPoolPerformanceReport.builder().build();
        }
    }
    
    /**
     * 计算性能指标
     * @param monitorReport 监控报告
     * @return 性能指标映射
     */
    private Map<String, ThreadPoolPerformanceMetrics> calculatePerformanceMetrics(ThreadPoolMonitorReport monitorReport) {
        Map<String, ThreadPoolPerformanceMetrics> metricsMap = new HashMap<>();
        
        try {
            for (ThreadPoolStatus status : monitorReport.getCurrentSnapshot().getStatuses()) {
                String poolName = status.getPoolName();
                
                // 计算CPU使用率
                double cpuUtilization = (double) status.getActiveThreadCount() / status.getMaximumPoolSize();
                
                // 计算内存使用率
                double memoryUtilization = (double) status.getCurrentPoolSize() / status.getMaximumPoolSize();
                
                // 计算吞吐量
                double throughput = status.getTotalTaskCount() > 0 ? 
                    (double) status.getCompletedTaskCount() / status.getTotalTaskCount() : 0.0;
                
                // 计算响应时间（模拟）
                double responseTime = status.getQueueSize() * 10.0; // 毫秒
                
                // 计算队列使用率
                double queueUtilization = (double) status.getQueueSize() / properties.getQueueCapacity();
                
                ThreadPoolPerformanceMetrics metrics = ThreadPoolPerformanceMetrics.builder()
                    .poolName(poolName)
                    .cpuUtilization(cpuUtilization)
                    .memoryUtilization(memoryUtilization)
                    .throughput(throughput)
                    .responseTime(responseTime)
                    .queueUtilization(queueUtilization)
                    .build();
                
                metricsMap.put(poolName, metrics);
            }
            
        } catch (Exception e) {
            log.error("计算性能指标失败", e);
        }
        
        return metricsMap;
    }
    
    /**
     * 生成优化建议
     * @param metricsMap 性能指标映射
     * @param alerts 告警列表
     * @return 优化建议列表
     */
    private List<ThreadPoolOptimizationRecommendation> generateOptimizationRecommendations(
            Map<String, ThreadPoolPerformanceMetrics> metricsMap, List<ThreadPoolAlert> alerts) {
        List<ThreadPoolOptimizationRecommendation> recommendations = new ArrayList<>();
        
        try {
            for (Map.Entry<String, ThreadPoolPerformanceMetrics> entry : metricsMap.entrySet()) {
                String poolName = entry.getKey();
                ThreadPoolPerformanceMetrics metrics = entry.getValue();
                
                // 基于CPU使用率提供建议
                if (metrics.getCpuUtilization() > 0.8) {
                    recommendations.add(new ThreadPoolOptimizationRecommendation(
                        "增加最大线程数",
                        "线程池 " + poolName + " CPU使用率过高，建议增加最大线程数",
                        "HIGH"
                    ));
                } else if (metrics.getCpuUtilization() < 0.3) {
                    recommendations.add(new ThreadPoolOptimizationRecommendation(
                        "减少最大线程数",
                        "线程池 " + poolName + " CPU使用率较低，建议减少最大线程数",
                        "MEDIUM"
                    ));
                }
                
                // 基于内存使用率提供建议
                if (metrics.getMemoryUtilization() > 0.8) {
                    recommendations.add(new ThreadPoolOptimizationRecommendation(
                        "增加队列容量",
                        "线程池 " + poolName + " 内存使用率过高，建议增加队列容量",
                        "HIGH"
                    ));
                }
                
                // 基于队列使用率提供建议
                if (metrics.getQueueUtilization() > 0.8) {
                    recommendations.add(new ThreadPoolOptimizationRecommendation(
                        "优化任务处理速度",
                        "线程池 " + poolName + " 队列使用率过高，建议优化任务处理速度",
                        "HIGH"
                    ));
                }
                
                // 基于吞吐量提供建议
                if (metrics.getThroughput() < 0.7) {
                    recommendations.add(new ThreadPoolOptimizationRecommendation(
                        "优化任务执行效率",
                        "线程池 " + poolName + " 吞吐量较低，建议优化任务执行效率",
                        "MEDIUM"
                    ));
                }
            }
            
            // 基于告警提供建议
            for (ThreadPoolAlert alert : alerts) {
                if ("HIGH".equals(alert.getSeverity())) {
                    recommendations.add(new ThreadPoolOptimizationRecommendation(
                        "处理" + alert.getTitle(),
                        alert.getDescription(),
                        "HIGH"
                    ));
                }
            }
            
        } catch (Exception e) {
            log.error("生成优化建议失败", e);
        }
        
        return recommendations;
    }
}

/**
 * 线程池性能指标
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ThreadPoolPerformanceMetrics {
    private String poolName;
    private double cpuUtilization;
    private double memoryUtilization;
    private double throughput;
    private double responseTime;
    private double queueUtilization;
}

/**
 * 线程池优化建议
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ThreadPoolOptimizationRecommendation {
    private String title;
    private String description;
    private String priority; // HIGH, MEDIUM, LOW
}

/**
 * 线程池性能分析报告
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ThreadPoolPerformanceReport {
    private Map<String, ThreadPoolPerformanceMetrics> metricsMap;
    private List<ThreadPoolAlert> alerts;
    private List<ThreadPoolOptimizationRecommendation> recommendations;
    private long analysisTime;
}

/**
 * Java线程池控制器
 */
@RestController
@RequestMapping("/api/v1/thread-pool")
public class JavaThreadPoolController {
    
    @Autowired
    private ThreadPoolPrincipleService principleService;
    
    @Autowired
    private ThreadPoolTuningService tuningService;
    
    @Autowired
    private ThreadPoolMonitor monitor;
    
    @Autowired
    private ThreadPoolPerformanceAnalyzer performanceAnalyzer;
    
    /**
     * 创建线程池
     */
    @PostMapping("/create")
    public ResponseEntity<Map<String, Object>> createThreadPool(@RequestBody ThreadPoolRequest request) {
        try {
            ThreadPoolExecutor executor = principleService.createThreadPoolExecutor(request.getPoolName());
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", true);
            response.put("message", "线程池创建成功");
            response.put("poolName", request.getPoolName());
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("创建线程池失败", e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "创建线程池失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
    
    /**
     * 执行任务
     */
    @PostMapping("/execute")
    public ResponseEntity<Map<String, Object>> executeTask(@RequestBody TaskRequest request) {
        try {
            ThreadTask task = new ThreadTask(request.getTaskName(), request.getDuration());
            Future<?> future = principleService.executeTask(request.getPoolName(), task);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", true);
            response.put("message", "任务提交成功");
            response.put("taskName", request.getTaskName());
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("执行任务失败", e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "执行任务失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
    
    /**
     * 获取线程池状态
     */
    @GetMapping("/status")
    public ResponseEntity<Map<String, Object>> getThreadPoolStatus(@RequestParam String poolName) {
        try {
            ThreadPoolStatus status = principleService.getThreadPoolStatus(poolName);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", true);
            response.put("status", status);
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("获取线程池状态失败", e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "获取线程池状态失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
    
    /**
     * 获取性能分析
     */
    @GetMapping("/performance")
    public ResponseEntity<Map<String, Object>> getPerformanceAnalysis(@RequestParam String poolName) {
        try {
            ThreadPoolPerformanceAnalysis analysis = tuningService.analyzePerformance(poolName);
            List<ThreadPoolTuningRecommendation> recommendations = tuningService.getTuningRecommendations(poolName);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", true);
            response.put("analysis", analysis);
            response.put("recommendations", recommendations);
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("获取性能分析失败", e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "获取性能分析失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
    
    /**
     * 获取监控报告
     */
    @GetMapping("/monitor")
    public ResponseEntity<Map<String, Object>> getMonitorReport() {
        try {
            ThreadPoolMonitorReport report = monitor.getMonitorReport();
            List<ThreadPoolAlert> alerts = monitor.getAlerts();
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", true);
            response.put("report", report);
            response.put("alerts", alerts);
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("获取监控报告失败", e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "获取监控报告失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
    
    /**
     * 获取性能分析报告
     */
    @GetMapping("/performance-report")
    public ResponseEntity<Map<String, Object>> getPerformanceReport() {
        try {
            ThreadPoolPerformanceReport report = performanceAnalyzer.analyzePerformance();
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", true);
            response.put("report", report);
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("获取性能分析报告失败", e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "获取性能分析报告失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
    
    /**
     * 调整线程池参数
     */
    @PostMapping("/adjust")
    public ResponseEntity<Map<String, Object>> adjustThreadPool(@RequestBody ThreadPoolAdjustRequest request) {
        try {
            boolean success = tuningService.adjustThreadPoolParameters(
                request.getPoolName(),
                request.getNewCorePoolSize(),
                request.getNewMaxPoolSize()
            );
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", success);
            response.put("message", success ? "线程池参数调整成功" : "线程池参数调整失败");
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("调整线程池参数失败", e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "调整线程池参数失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
}

/**
 * 线程池请求模型
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ThreadPoolRequest {
    private String poolName;
}

/**
 * 任务请求模型
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class TaskRequest {
    private String poolName;
    private String taskName;
    private int duration; // 毫秒
}

/**
 * 线程池调整请求模型
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ThreadPoolAdjustRequest {
    private String poolName;
    private int newCorePoolSize;
    private int newMaxPoolSize;
}