/**
 * 问题代码：使用了危险的newFixedThreadPool
 */
public class DataSaveService {

    // ❌ 危险：使用无界队列的线程池
    private ExecutorService executorService = Executors.newFixedThreadPool(5);

    public void saveBatch() {
        executorService.execute(() -> {
            saveData();  // 数据库保存操作
        });
    }

    private void saveData() {
        // 数据库插入逻辑
        // 由于主键设计问题，插入性能较慢
    }
}

// Executors.newFixedThreadPool 源码
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(
        nThreads,           // 核心线程数
        nThreads,           // 最大线程数
        0L,                 // 线程空闲时间
        TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue<Runnable>()  // ⚠️ 无界队列！
    );
}

/**
 * 优化后的线程池配置
 * 关键改进：有界队列 + 自定义拒绝策略
 */
@Configuration
public class ThreadPoolConfig {

    @Bean("dataSaveThreadPool")
    public ThreadPoolExecutor dataSaveThreadPool() {
        int coreSize = Runtime.getRuntime().availableProcessors();
        int maxSize = coreSize * 2;

        return new ThreadPoolExecutor(
            coreSize,                           // 核心线程数
            maxSize,                            // 最大线程数
            60L,                                // 线程空闲时间
            TimeUnit.SECONDS,                   // 时间单位
            new LinkedBlockingQueue<>(10000),   // ✅ 有界队列，容量10000
            new ThreadFactoryBuilder()
                .setNameFormat("data-save-%d")
                .setDaemon(false)
                .build(),
            new CustomRejectedHandler()         // ✅ 自定义拒绝策略
        );
    }

    /**
     * 自定义拒绝策略：MQ补偿机制
     */
    public static class CustomRejectedHandler implements RejectedExecutionHandler {

        @Autowired
        private RabbitTemplate rabbitTemplate;

        @Override
        public void rejectedExecution(Runnable task, ThreadPoolExecutor executor) {
            try {
                // 📨 将被拒绝的任务发送到MQ进行异步处理
                if (task instanceof DataSaveTask) {
                    DataSaveTask saveTask = (DataSaveTask) task;
                    rabbitTemplate.convertAndSend(
                        "data.save.queue",
                        saveTask.getData()
                    );
                    log.warn("任务队列已满，已转发到MQ处理: {}", saveTask.getId());
                } else {
                    // 其他任务直接在调用线程执行
                    task.run();
                }
            } catch (Exception e) {
                log.error("拒绝策略处理失败", e);
                // 最后兜底：调用线程执行
                if (!executor.isShutdown()) {
                    task.run();
                }
            }
        }
    }
}

/**
 * 要求上游系统按主键排序后插入
 * 减少页面分裂，提升插入性能
 */
@Service
public class DataSaveService {

    public void saveBatchSorted(List<ComponentData> dataList) {
        // ✅ 按主键排序后插入
        List<ComponentData> sortedList = dataList.stream()
            .sorted(Comparator.comparing(ComponentData::getPartNoSn))
            .collect(Collectors.toList());

        batchInsert(sortedList);
    }

    @Transactional(rollbackFor = Exception.class)
    public void batchInsert(List<ComponentData> dataList) {
        // 分批插入，避免单次事务过大
        int batchSize = 1000;
        for (int i = 0; i < dataList.size(); i += batchSize) {
            int end = Math.min(i + batchSize, dataList.size());
            List<ComponentData> batch = dataList.subList(i, end);
            componentDataMapper.batchInsert(batch);
        }
    }
}

/**
 * 线程池监控组件
 */
@Component
public class ThreadPoolMonitor {

    @Autowired
    private ThreadPoolExecutor dataSaveThreadPool;

    @Scheduled(fixedRate = 30000) // 每30秒检查一次
    public void monitorThreadPool() {
        int queueSize = dataSaveThreadPool.getQueue().size();
        int activeCount = dataSaveThreadPool.getActiveCount();
        long completedTasks = dataSaveThreadPool.getCompletedTaskCount();

        // 记录监控指标
        Metrics.gauge("threadpool.queue.size", queueSize);
        Metrics.gauge("threadpool.active.count", activeCount);
        Metrics.counter("threadpool.completed.tasks", completedTasks);

        // 队列积压预警
        if (queueSize > 8000) {
            log.warn("⚠️ 线程池队列积压严重: {}", queueSize);
            alertService.sendAlert("线程池队列积压", queueSize);
        }

        // 拒绝任务统计
        if (dataSaveThreadPool instanceof ThreadPoolExecutor) {
            ThreadPoolExecutor executor = (ThreadPoolExecutor) dataSaveThreadPool;
            // 这里可以通过自定义RejectedExecutionHandler统计拒绝次数
        }
    }
}

/**
 * 不同场景的线程池配置建议
 */
public class ThreadPoolBestPractices {

    // CPU密集型任务
    public ThreadPoolExecutor cpuIntensivePool() {
        int coreSize = Runtime.getRuntime().availableProcessors();
        return new ThreadPoolExecutor(
            coreSize, coreSize + 1, 60L, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(100),
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
    }

    // I/O密集型任务
    public ThreadPoolExecutor ioIntensivePool() {
        int coreSize = Runtime.getRuntime().availableProcessors() * 2;
        return new ThreadPoolExecutor(
            coreSize, coreSize * 2, 60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1000),
            new ThreadPoolExecutor.AbortPolicy()
        );
    }

    // 混合型任务
    public ThreadPoolExecutor mixedPool() {
        int processors = Runtime.getRuntime().availableProcessors();
        return new ThreadPoolExecutor(
            processors, processors * 2, 60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(500),
            new CustomRejectedHandler()
        );
    }
}