线程池详解

public ThreadPoolExecutor(
    int corePoolSize,           // 核心线程数
    int maximumPoolSize,        // 最大线程数
    long keepAliveTime,         // 空闲线程存活时间
    TimeUnit unit,              // 时间单位
    BlockingQueue<Runnable> workQueue,  // 工作队列
    ThreadFactory threadFactory,        // 线程工厂
    RejectedExecutionHandler handler    // 拒绝策略
)

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 飞翔科技 —— 员工年终绩效奖金批量计算
 */
public class EmployeeBonusCalculator {

    // 自定义线程工厂：给线程起有意义的名字
    static class FeixiangThreadFactory implements ThreadFactory {
        private final AtomicInteger counter = new AtomicInteger(1);
        private final String prefix;

        public FeixiangThreadFactory(String prefix) {
            this.prefix = prefix;
        }

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, prefix + "-" + counter.getAndIncrement());
            t.setDaemon(false);  // 非守护线程，保证任务执行完
            t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

    // 模拟员工绩效计算任务
    static class BonusTask implements Callable<String> {
        private final int employeeId;
        private final String employeeName;

        public BonusTask(int employeeId, String employeeName) {
            this.employeeId = employeeId;
            this.employeeName = employeeName;
        }

        @Override
        public String call() throws Exception {
            // 模拟耗时计算
            long computeTime = 200 + (long)(Math.random() * 800);
            Thread.sleep(computeTime);
            double bonus = 5000 + Math.random() * 15000;
            return String.format("员工[%d] %s: 年终奖金 ¥%.2f (计算耗时 %dms)",
                    employeeId, employeeName, bonus, computeTime);
        }
    }

    public static void main(String[] args) {
        // 手动构造 ThreadPoolExecutor —— 七个参数全掌控
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                4,                              // corePoolSize: 核心4个线程常驻
                8,                              // maximumPoolSize: 最多8个线程
                60L,                            // keepAliveTime: 空闲60秒
                TimeUnit.SECONDS,               // 时间单位
                new LinkedBlockingQueue<>(20),   // 有界队列，容量20
                new FeixiangThreadFactory("bonus-worker"),  // 自定义线程工厂
                new ThreadPoolExecutor.CallerRunsPolicy()    // 拒绝策略：调用者运行
        );

        // 允许核心线程超时回收（JDK 8 新方法）
        executor.allowCoreThreadTimeOut(false);

        // 提交 100 个计算任务
        CompletionService<String> completionService =
                new ExecutorCompletionService<>(executor);

        String[] names = {"张伟", "李娜", "王磊", "陈静", "赵强", "孙莉", "周杰", "吴敏",
                          "郑浩", "钱雪", "冯涛", "蒋琳", "韩冰", "杨帆", "朱峰", "秦月",
                          "尤佳", "许明", "何琳", "吕华"};

        System.out.println("===== 飞翔科技年终绩效计算开始 =====");
        System.out.println("线程池状态 - 核心: " + executor.getCorePoolSize()
                + ", 最大: " + executor.getMaximumPoolSize()
                + ", 队列容量: 20");
        System.out.println("共需计算员工数: 100");

        for (int i = 0; i < 100; i++) {
            final int employeeId = 1001 + i;
            final String name = names[i % names.length] + (i / names.length + 1);
            completionService.submit(new BonusTask(employeeId, name));
        }

        // 按完成顺序获取结果
        System.out.println("\n===== 计算结果（按完成先后顺序输出）=====");
        for (int i = 0; i < 100; i++) {
            try {
                Future<String> future = completionService.take();
                System.out.println("[" + (i + 1) + "] " + future.get());
            } catch (InterruptedException | ExecutionException e) {
                System.err.println("计算失败: " + e.getMessage());
            }
        }

        System.out.println("\n===== 线程池统计 =====");
        System.out.println("已完成任务数: " + executor.getCompletedTaskCount());
        System.out.println("历史最大线程数: " + executor.getLargestPoolSize());
        System.out.println("当前活跃线程数: " + executor.getActiveCount());

        // 优雅关闭
        executor.shutdown();
        try {
            if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }
        System.out.println("线程池已关闭，程序结束。");
    }
}

import java.util.concurrent.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * 飞翔科技 —— 定时系统健康检查与维护
 */
public class SystemHealthScheduler {

    private static final DateTimeFormatter fmt =
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    // 模拟健康指标采集
    static class HealthCollectTask implements Runnable {
        private final int serverId;

        public HealthCollectTask(int serverId) {
            this.serverId = serverId;
        }

        @Override
        public void run() {
            double cpuUsage = 20 + Math.random() * 60;
            double memoryUsage = 30 + Math.random() * 50;
            String status = cpuUsage > 80 ? "⚠ 警告" : "✓ 正常";

            System.out.printf("[%s] 服务器 #%d | CPU: %.1f%% | 内存: %.1f%% | %s%n",
                    LocalDateTime.now().format(fmt), serverId,
                    cpuUsage, memoryUsage, status);
        }
    }

    // 模拟数据库清理任务
    static class DatabaseCleanupTask implements Runnable {
        @Override
        public void run() {
            System.out.println("\n========================================");
            System.out.printf("[%s] 开始执行数据库过期日志清理...%n",
                    LocalDateTime.now().format(fmt));
            System.out.println("清理 30 天前的操作日志...");
            System.out.println("清理 90 天前的审计记录...");
            System.out.println("重建索引...");
            System.out.println("数据库清理完成！");
            System.out.println("========================================\n");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ScheduledThreadPoolExecutor scheduler = new ScheduledThreadPoolExecutor(
                3,
                new ThreadFactory() {
                    private int count = 0;
                    @Override
                    public Thread newThread(Runnable r) {
                        return new Thread(r, "scheduler-" + (++count));
                    }
                },
                new ThreadPoolExecutor.DiscardPolicy()  // 任务过多时丢弃
        );

        System.out.println("===== 飞翔科技系统健康监控启动 =====");
        System.out.println("当前时间: " + LocalDateTime.now().format(fmt));

        // 任务1：初始延迟1秒，每5秒执行一次（采集3台服务器指标）
        scheduler.scheduleAtFixedRate(
                new HealthCollectTask(1), 1, 5, TimeUnit.SECONDS);
        scheduler.scheduleAtFixedRate(
                new HealthCollectTask(2), 2, 5, TimeUnit.SECONDS);

        // 任务2：延迟执行（模拟每天凌晨2点清理——这里用10秒后执行做演示）
        scheduler.schedule(new DatabaseCleanupTask(), 10, TimeUnit.SECONDS);

        // 运行20秒后关闭
        Thread.sleep(20000);

        System.out.println("\n调度器关闭中...");
        scheduler.shutdown();
        if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
            scheduler.shutdownNow();
        }
        System.out.println("调度器已关闭。");
    }
}

// execute 方式
executor.execute(() -> {
    int result = 1 / 0;  // 异常会被 UncaughtExceptionHandler 捕获
});

// submit 方式
Future<Integer> future = executor.submit(() -> {
    return 1 / 0;  // 异常在 future.get() 时抛出 ExecutionException
});
try {
    future.get();
} catch (ExecutionException e) {
    System.out.println("捕获到任务异常: " + e.getCause());
}

// ❌ 错误：corePoolSize > maximumPoolSize 会抛出 IllegalArgumentException
ThreadPoolExecutor pool = new ThreadPoolExecutor(
    10,    // corePoolSize = 10
    5,     // maximumPoolSize = 5  ← 小于 corePoolSize!
    60, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(10),
    Executors.defaultThreadFactory(),
    new ThreadPoolExecutor.AbortPolicy()
);
// 运行结果：java.lang.IllegalArgumentException

// ❌ 危险：LinkedBlockingQueue 无参构造 = 无界队列（容量 Integer.MAX_VALUE）
ThreadPoolExecutor pool = new ThreadPoolExecutor(
    5, 10, 60, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(),  // 无界队列！任务可以无限堆积
    Executors.defaultThreadFactory(),
    new ThreadPoolExecutor.AbortPolicy()
);

// 高并发下任务堆积到内存耗尽 → OutOfMemoryError
for (int i = 0; i < 10_000_000; i++) {
    pool.execute(() -> {
        try { Thread.sleep(10000); } catch (InterruptedException e) {}
    });
}

// ❌ 错误：线程池未关闭，非守护线程存活导致 JVM 挂起
ThreadPoolExecutor pool = new ThreadPoolExecutor(
    2, 4, 60, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(10),
    new ThreadFactory() {
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setDaemon(false);  // 非守护线程
            return t;
        }
    },
    new ThreadPoolExecutor.AbortPolicy()
);

pool.execute(() -> System.out.println("任务执行完毕"));
// 忘记调用 pool.shutdown() → JVM 不会退出！

// ❌ 错误：shutdownNow() 会返回未执行的任务列表，不处理就会丢失
List<Runnable> abandoned = pool.shutdownNow();
// abandoned 包含所有尚未开始执行的任务，直接忽略则丢失
System.out.println("丢弃了 " + abandoned.size() + " 个任务");  // 应该重新提交或持久化