Java线程池核心参数原理及使用指南

// 主要接口和类
Executor          // 执行器接口
ExecutorService   // 执行服务接口
ThreadPoolExecutor // 线程池核心实现类
ScheduledThreadPoolExecutor // 支持定时调度的线程池
Executors         // 线程池工厂类

public ThreadPoolExecutor(
    int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue,
    ThreadFactory threadFactory,
    RejectedExecutionHandler handler
)

// 自定义线程工厂示例
ThreadFactory customThreadFactory = new ThreadFactory() {
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r);
        thread.setName("MyThread-" + threadNumber.getAndIncrement());
        thread.setDaemon(false);
        thread.setPriority(Thread.NORM_PRIORITY);
        return thread;
    }
};

// 线程池工作流程伪代码
public void execute(Runnable task) {
    if (当前线程数 < corePoolSize) {
        创建新线程执行任务;
    } else if (工作队列未满) {
        将任务加入工作队列;
    } else if (当前线程数 < maximumPoolSize) {
        创建新线程执行任务;
    } else {
        执行拒绝策略;
    }
}

任务提交
    ↓
当前线程数 < corePoolSize? → 是 → 创建核心线程执行
    ↓否
工作队列未满? → 是 → 任务入队等待
    ↓否
当前线程数 < maximumPoolSize? → 是 → 创建非核心线程执行
    ↓否
执行拒绝策略

// 1. 固定大小线程池
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
// 特点：核心线程数=最大线程数，使用无界队列
// 2. 单线程线程池
ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
// 特点：只有一个线程，任务顺序执行
// 3. 缓存线程池
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
// 特点：核心线程数为0，最大线程数为Integer.MAX_VALUE，使用同步队列
// 4. 定时任务线程池
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
// 支持定时和周期性任务

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5,                                      // corePoolSize
    10,                                     // maximumPoolSize
    60L,                                    // keepAliveTime
    TimeUnit.SECONDS,                       // unit
    new ArrayBlockingQueue<>(100),          // workQueue
    Executors.defaultThreadFactory(),       // threadFactory
    new ThreadPoolExecutor.AbortPolicy()    // handler
);

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2, 5, 60, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(10),
            new CustomThreadFactory(),
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
        // 提交任务
        for (int i = 1; i <= 20; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + 
                                 " 执行任务 " + taskId);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        // 监控线程池状态
        monitorThreadPool(executor);
        // 优雅关闭
        executor.shutdown();
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
    // 自定义线程工厂
    static class CustomThreadFactory implements ThreadFactory {
        private final AtomicInteger counter = new AtomicInteger(1);
        @Override
        public Thread newThread(Runnable r) {
            Thread thread = new Thread(r);
            thread.setName("CustomThread-" + counter.getAndIncrement());
            thread.setDaemon(false);
            thread.setPriority(Thread.NORM_PRIORITY);
            return thread;
        }
    }
    // 监控线程池状态
    private static void monitorThreadPool(ThreadPoolExecutor executor) {
        new Thread(() -> {
            while (!executor.isTerminated()) {
                System.out.println("=== 线程池状态监控 ===");
                System.out.println("核心线程数: " + executor.getCorePoolSize());
                System.out.println("当前线程数: " + executor.getPoolSize());
                System.out.println("活跃线程数: " + executor.getActiveCount());
                System.out.println("队列大小: " + executor.getQueue().size());
                System.out.println("完成任务数: " + executor.getCompletedTaskCount());
                System.out.println("总任务数: " + executor.getTaskCount());
                System.out.println("========================\n");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }).start();
    }
}

// 线程数 ≈ CPU核心数 + 1
int corePoolSize = Runtime.getRuntime().availableProcessors() + 1;

// 线程数 ≈ CPU核心数 * 2
// 或根据具体IO等待时间调整
int corePoolSize = Runtime.getRuntime().availableProcessors() * 2;

// Java 1.7+ 支持动态调整参数
executor.setCorePoolSize(10);
executor.setMaximumPoolSize(20);
executor.setKeepAliveTime(120, TimeUnit.SECONDS);