import java.util.concurrent.*;
import java.util.Random;
public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 1. 創(chuàng)建線程池
        // 核心參數(shù)：核心線程數(shù)5，最大線程數(shù)10，空閑時間60秒，任務隊列容量100
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            5,  // corePoolSize
            10, // maximumPoolSize
            60, // keepAliveTime
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(100), // 任務隊列
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy() // 拒絕策略
        );
        // 2. 提交任務
        for (int i = 1; i <= 20; i++) {
            int taskId = i;
            executor.execute(() -> {
                System.out.println("處理任務" + taskId + 
                    ", 線程: " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模擬業(yè)務處理
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        // 3. 優(yōu)雅關(guān)閉
        executor.shutdown();
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }
    }
}

import java.util.concurrent.*;
import java.util.List;
import java.util.ArrayList;
public class OrderProcessor {
    // 使用單例模式創(chuàng)建線程池
    private static final ThreadPoolExecutor orderExecutor = new ThreadPoolExecutor(
        3, 8, 30, TimeUnit.SECONDS,
        new ArrayBlockingQueue<>(1000),
        new ThreadFactory() {
            private int count = 0;
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r, "order-process-" + (++count));
                thread.setDaemon(false);
                return thread;
            }
        },
        new ThreadPoolExecutor.CallerRunsPolicy() // 拒絕策略：調(diào)用者線程執(zhí)行
    );
    /**
     * 異步處理訂單
     */
    public CompletableFuture<Void> processOrderAsync(Order order) {
        return CompletableFuture.runAsync(() -> {
            try {
                // 1. 驗證訂單
                validateOrder(order);
                // 2. 扣減庫存
                reduceInventory(order);
                // 3. 生成發(fā)貨單
                generateShipping(order);
                // 4. 發(fā)送通知
                sendNotification(order);
                System.out.println("訂單處理完成: " + order.getId());
            } catch (Exception e) {
                // 記錄異常，進行補償
                handleOrderException(order, e);
            }
        }, orderExecutor);
    }
    /**
     * 批量處理訂單
     */
    public CompletableFuture<Void> batchProcessOrders(List<Order> orders) {
        List<CompletableFuture<Void>> futures = new ArrayList<>();
        for (Order order : orders) {
            CompletableFuture<Void> future = processOrderAsync(order);
            futures.add(future);
        }
        // 等待所有任務完成
        return CompletableFuture.allOf(
            futures.toArray(new CompletableFuture[0])
        );
    }
    // 業(yè)務方法（模擬實現(xiàn)）
    private void validateOrder(Order order) {
        // 驗證邏輯
    }
    private void reduceInventory(Order order) {
        // 扣減庫存邏輯
    }
    private void generateShipping(Order order) {
        // 生成發(fā)貨單邏輯
    }
    private void sendNotification(Order order) {
        // 發(fā)送通知
    }
    private void handleOrderException(Order order, Exception e) {
        // 異常處理
    }
    // 優(yōu)雅關(guān)閉
    public void shutdown() {
        orderExecutor.shutdown();
    }
    // 訂單類
    static class Order {
        private String id;
        // 其他字段
        public String getId() { return id; }
    }
}

import java.util.concurrent.*;
import java.util.List;
import java.io.File;
public class DataExportService {
    // 專門用于導出任務的線程池
    private static final ThreadPoolExecutor exportExecutor = new ThreadPoolExecutor(
        2, 4, 5, TimeUnit.MINUTES,
        new LinkedBlockingQueue<>(50),
        new ThreadFactory() {
            private int count = 0;
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r, "export-thread-" + (++count));
                thread.setPriority(Thread.NORM_PRIORITY);
                return thread;
            }
        },
        new ThreadPoolExecutor.DiscardOldestPolicy() // 拒絕策略：丟棄最老任務
    );
    /**
     * 異步導出Excel
     */
    public CompletableFuture<File> exportExcelAsync(String exportId, 
                                                     List<?> dataList) {
        return CompletableFuture.supplyAsync(() -> {
            System.out.println("開始導出數(shù)據(jù)，任務ID: " + exportId);
            try {
                // 模擬大數(shù)據(jù)量處理
                File excelFile = generateExcelFile(dataList);
                // 模擬上傳到云存儲
                String url = uploadToCloudStorage(excelFile);
                // 記錄導出日志
                saveExportLog(exportId, url, "SUCCESS");
                return excelFile;
            } catch (Exception e) {
                saveExportLog(exportId, null, "FAILED");
                throw new RuntimeException("導出失敗", e);
            }
        }, exportExecutor);
    }
    /**
     * 帶進度的數(shù)據(jù)導出
     */
    public CompletableFuture<File> exportWithProgress(String exportId, 
                                                      List<?> dataList,
                                                      ProgressCallback callback) {
        return CompletableFuture.supplyAsync(() -> {
            int total = dataList.size();
            int batchSize = 1000;
            int processed = 0;
            for (int i = 0; i < total; i += batchSize) {
                int end = Math.min(i + batchSize, total);
                List<?> batchData = dataList.subList(i, end);
                // 處理批次數(shù)據(jù)
                processBatchData(batchData);
                processed = end;
                float progress = (float) processed / total;
                // 回調(diào)更新進度
                if (callback != null) {
                    callback.onProgress(progress);
                }
                // 模擬處理時間
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            return generateExcelFile(dataList);
        }, exportExecutor);
    }
    // 業(yè)務方法（模擬實現(xiàn)）
    private File generateExcelFile(List<?> dataList) {
        // 生成Excel文件
        return new File("export.xlsx");
    }
    private String uploadToCloudStorage(File file) {
        // 上傳到云存儲
        return "https://oss.example.com/" + file.getName();
    }
    private void saveExportLog(String exportId, String url, String status) {
        // 保存日志
    }
    private void processBatchData(List<?> batchData) {
        // 處理批次數(shù)據(jù)
    }
    // 進度回調(diào)接口
    public interface ProgressCallback {
        void onProgress(float progress);
    }
    // 獲取線程池狀態(tài)
    public void printThreadPoolStatus() {
        System.out.println("核心線程數(shù): " + exportExecutor.getCorePoolSize());
        System.out.println("活動線程數(shù): " + exportExecutor.getActiveCount());
        System.out.println("任務隊列大小: " + exportExecutor.getQueue().size());
        System.out.println("已完成任務數(shù): " + exportExecutor.getCompletedTaskCount());
    }
}

// 模擬處理時間
try {
    Thread.sleep(100);
} catch (InterruptedException e) {
    // 就是這一句！重新設置中斷狀態(tài)
    Thread.currentThread().interrupt();
}

import java.util.concurrent.*;
import java.time.LocalDateTime;
public class ScheduledTaskService {
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(3);
    /**
     * 初始化定時任務
     */
    public void initScheduledTasks() {
        // 1. 每天凌晨執(zhí)行數(shù)據(jù)清理
        scheduleDailyCleanup();
        // 2. 每5分鐘執(zhí)行一次數(shù)據(jù)同步
        schedulePeriodicSync();
        // 3. 延遲執(zhí)行一次性任務
        scheduleOneTimeTask();
    }
    /**
     * 每天凌晨2點執(zhí)行數(shù)據(jù)清理
     */
    private void scheduleDailyCleanup() {
        long initialDelay = calculateInitialDelay(2, 0); // 凌晨2點
        long period = 24 * 60 * 60; // 24小時
        scheduler.scheduleAtFixedRate(() -> {
            try {
                System.out.println("開始數(shù)據(jù)清理: " + LocalDateTime.now());
                cleanUpOldData();
                System.out.println("數(shù)據(jù)清理完成: " + LocalDateTime.now());
            } catch (Exception e) {
                System.err.println("數(shù)據(jù)清理失敗: " + e.getMessage());
            }
        }, initialDelay, period, TimeUnit.SECONDS);
    }
    /**
     * 每5分鐘執(zhí)行數(shù)據(jù)同步
     */
    private void schedulePeriodicSync() {
        scheduler.scheduleWithFixedDelay(() -> {
            try {
                syncDataWithExternalSystem();
            } catch (Exception e) {
                // 記錄異常，下次繼續(xù)執(zhí)行
                System.err.println("數(shù)據(jù)同步失敗: " + e.getMessage());
            }
        }, 0, 5, TimeUnit.MINUTES);
    }
    /**
     * 延遲10秒執(zhí)行一次性任務
     */
    private void scheduleOneTimeTask() {
        scheduler.schedule(() -> {
            System.out.println("執(zhí)行一次性任務: " + LocalDateTime.now());
        }, 10, TimeUnit.SECONDS);
    }
    /**
     * 提交可取消的定時任務
     */
    public ScheduledFuture<?> submitCancellableTask(Runnable task, 
                                                    long initialDelay, 
                                                    long period, 
                                                    TimeUnit unit) {
        return scheduler.scheduleAtFixedRate(task, initialDelay, period, unit);
    }
    // 工具方法：計算到指定時間的延遲
    private long calculateInitialDelay(int targetHour, int targetMinute) {
        LocalDateTime now = LocalDateTime.now();
        LocalDateTime targetTime = now.withHour(targetHour)
                                     .withMinute(targetMinute)
                                     .withSecond(0);
        if (now.isAfter(targetTime)) {
            targetTime = targetTime.plusDays(1);
        }
        return java.time.Duration.between(now, targetTime).getSeconds();
    }
    // 業(yè)務方法
    private void cleanUpOldData() {
        // 清理過期數(shù)據(jù)
    }
    private void syncDataWithExternalSystem() {
        // 同步數(shù)據(jù)
    }
    public void shutdown() {
        scheduler.shutdown();
    }
}

@Component
@Slf4j
public class DataCleanupTask {
    // 從配置文件讀取 Cron 表達式，例如：0 0 2 * * ? (每天凌晨2點)
    @Scheduled(cron = "${task.cleanup.cron}")
    public void dailyCleanup() {
        log.info("開始數(shù)據(jù)清理...");
        try {
            // 業(yè)務邏輯
        } catch (Exception e) {
            log.error("清理失敗", e);
        }
    }
}

@Scheduled(cron = "0 0 2 * * ?")
@SchedulerLock(name = "dataCleanupTask", lockAtMostFor = "10m", lockAtLeastFor = "1m")
public void scheduledTask() {
    // 只有搶到鎖的機器才會執(zhí)行
}