如何优雅的创建线程池

在Java中，通过java.util.concurrent.Executors类可以方便地创建四种常见的线程池，每种线程池适用于不同的场景。以下是这四种线程池的创建方式及其特点：

1. 可缓存线程池 (newCachedThreadPool)

   ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

   特点：线程池中线程的数量不确定，可以根据需要动态创建线程，如果线程空闲时间超过60秒，则会被回收。适用于执行很多短期异步任务的场景。

2. 定长线程池 (newFixedThreadPool)

   ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);

   特点：线程池大小固定，可控制并发数，超出的任务将在队列中等待。适合执行大量同类任务，能有效控制资源消耗。

3. 单线程线程池 (newSingleThreadExecutor)

   ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

   特点：只创建一个工作线程，所有的任务都在这个线程中按顺序执行。适合不需要并发但希望顺序执行任务的场景。

4. 定时线程池 (newScheduledThreadPool)

   ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

   特点：可以安排任务在未来的某个时间执行，或者定期执行。线程池大小固定，适用于需要执行定时任务或周期性任务的场景。

        创建一个合理配置的线程池涉及多个因素，包括预计的任务数量、任务性质（CPU密集型还是IO密集型）、系统资源限制等。为了更精确地控制线程池的参数，如核心线程数、最大线程数、线程存活时间、任务队列类型和拒绝策略等，从而更好地满足特定应用的需求，在项目开发中推荐直接使用ThreadPoolExecutor类来定制线程池。

示例：创建一个合理的线程池

下面是一个创建线程池的示例代码，这个例子考虑了常见的一些参数设置：

import java.util.concurrent.*;

public class ThreadPoolExample {

    public static void main(String[] args) {
        // 核心线程数：根据CPU核心数动态调整，对于CPU密集型任务，一般设为核心数+1或者核心数
        int corePoolSize = Runtime.getRuntime().availableProcessors() + 1;
        
        // 最大线程数：考虑到系统负载，这里设为核心数的两倍，对于IO密集型任务，可以设置得更大
        int maximumPoolSize = corePoolSize * 2;
        
        // 空闲线程存活时间：如果线程池中的线程数量超过核心线程数，那么在空闲时间达到keepAliveTime后，多余的线程会被终止
        long keepAliveTime = 60L; // 单位：秒
        
        // 阻塞队列：用于存储等待执行的任务，ArrayBlockingQueue是一个有界的阻塞队列，可以防止资源耗尽
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(100); // 队列大小根据实际情况调整
        
        // 线程工厂：可以定制线程的创建，如命名线程等
        ThreadFactory threadFactory = new ThreadPoolExecutor.CallerRunsPolicy();
        //ThreadFactory threadFactory = Executors.defaultThreadFactory();
        //ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("MyCustomThread-%d").build();
        
        // 拒绝策略：当队列已满且线程数达到最大时，如何处理新来的任务
        RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy(); // 抛出异常拒绝新任务
        
        // 创建线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                corePoolSize,
                maximumPoolSize,
                keepAliveTime,
                TimeUnit.SECONDS,
                workQueue,
                threadFactory,
                handler
        );
        
        // 提交任务到线程池
        for (int i = 0; i < 20; i++) {
            Runnable worker = new WorkerThread("" + i);
            executor.execute(worker);
        }
        
        // 关闭线程池
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("所有任务已完成");
    }
    
    private static class WorkerThread implements Runnable {
        private String command;
        
        public WorkerThread(String s) {
            this.command = s;
        }
        
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " 开始处理命令 : " + command);
            processCommand();
            System.out.println(Thread.currentThread().getName() + " 完成处理命令 : " + command);
        }
        
        private void processCommand() {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

补充一下，对于IO密集型任务，合理设置核心线程数的一个常见做法是设置得比CPU核心数要多，因为IO密集型任务在执行过程中往往会遇到大量的等待时间，如文件读写、网络通信等。在这段时间里，线程实际上是被阻塞的，CPU可以被其他线程使用。因此，增加线程数可以使得在某些线程等待IO时，CPU能够调度其他线程执行，提高CPU利用率。

一种常用的估算方法是将核心线程数设置为CPU核心数的2倍，即：

int cpuCoreCount = Runtime.getRuntime().availableProcessors();
int ioIntensiveCorePoolSize = cpuCoreCount * 2;

另一种更精细的方法是考虑阻塞系数，即线程在执行过程中阻塞等待的时间占总执行时间的比例。如果已知阻塞系数（比如假设为0.8，意味着线程80%的时间在等待IO），那么可以使用如下公式来估算：

int blockingCoefficient = 0.8; // 假设阻塞系数为0.8
int ioIntensiveCorePoolSize = (int) Math.ceil(cpuCoreCount / (1 - blockingCoefficient));

这个公式反映了这样一个原则：如果线程大部分时间在等待，那么可以安全地拥有更多线程，以确保CPU始终忙碌。然而，实际设置时还需要考虑系统的具体负载、任务的特性以及资源限制，可能需要通过压力测试和性能监控来微调这些参数，以达到最佳性能。同时，确保有合理的最大线程数限制和队列策略，以防资源耗尽。