Java线程池让使用线程变得更加高效

使用一个线程需要经过创建、运行、销毁三大步骤，如果业务系统每个线程都要经历这个过程，那势必带来过多不必要的资源消耗。线程池就是为了解决这个问题而生，需要时就从池中拿取，使用完毕就放回去，池化思想通过复用对象大大提高了系统的性能。线程池、数据库连接池、对象池等都采用了池化技术，下面我们就来学习下线程池的核心知识、面试重点~

文章目录

- 1. 线程池使用
- - 1.1 如何配置线程池大小
  - 1.2 创建线程池
  - 1.3 预配置线程池弊端
  - 1.3 Spring创建线程池
- 2. 线程池拒绝策略
- 3. 线程工厂的作用
- 未完待续。。。

1. 线程池使用

1.1 如何配置线程池大小

面试官：你说下线程池的大小要怎么配置？

这个问题要看业务系统执行的任务更多的是计算密集型任务，还是I/O密集型任务。大家可以从这两个方面来回答面试官。

（1）如果是计算密集型任务，通常情况下，CPU个数为N，设置N + 1个线程数量能够实现最优的资源利用率。因为N + 1个线程能保证至少有N个线程在利用CPU，提高了CPU利用率；同时不设置过多的线程也能减少线程状态切换所带来的上下文切换消耗。

（2）如果是I/O密集型任务，线程的主要等待时间是花在等待I/O操作上，另外就是计算所花费的时间。一般可以根据这个公式得出线程池合适的大小配置。
$线程池大小 = CP U 数量 * CP U 期望的利用率 * (1 + I O 操作等待时间 / CP U 计算时间)$

1.2 创建线程池

面试官：那线程池怎么创建？

可以使用ThreadPoolExecutor自定义创建线程池，这也是创建线程池推荐的创建方式。

public ThreadPoolExecutor(int corePoolSize, // 要保留在池中的线程数
                          int maximumPoolSize, // 池中允许的最大线程数
                          long keepAliveTime, // 当线程数大于corePoolSize时，多余的空闲线程在终止之前等待新任务的最长时间
                          TimeUnit unit, // 时间单位
                          BlockingQueue<Runnable> workQueue, // 在执行任务之前用于保存任务的队列
                          ThreadFactory threadFactory) { // 执行程序创建新线程时使用的工厂
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         threadFactory, defaultHandler);
}

另外Executors类也提供了一些静态工厂方法，可以用来创建一些预配置的线程池。

newFixedThreadPool可以设置线程池的固定线程数量。

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

newSingleThreadExecutor可以让线程按序执行，适用于需要确保所有任务按序执行的场景。

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

大家看下以下源码，newCachedThreadPool的线程数没有上限限制，同时空闲线程的存活时间是60秒。newCachedThreadPool更适合系统负载不太高、线程执行时间短的场景下，因为线程任务不需要经过排队，直接交给空闲线程就可以。

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

newScheduledThreadPool可以安排任务在给定的延迟后运行，或者定期执行。

public static ScheduledExecutorService newScheduledThreadPool(
        int corePoolSize, ThreadFactory threadFactory) {
    return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}

1.3 预配置线程池弊端

面试官：你说的这些预配置线程池会有什么问题？

小伙伴要记得上述静态工厂方法在使用过程中可能会出现OOM内存溢出的情况。

newFixedThreadPool、newSingleThreadExecutor：因为线程池指定的请求队列类型是链表队列LinkedBlockingQueue<Runnable>()，故允许的请求队列长度是无上限的，可能会出现OOM内存溢出。
newCachedThreadPool、newScheduledThreadPool：线程池指定的线程数上限是Integer.MAX_VALUE，故允许创建的线程数量是无上限的Integer.MAX_VALUE，可能会出现OOM内存溢出。

1.3 Spring创建线程池

面试官：你们项目线程池用的这种创建方式？

一般Spring工程创建线程池不直接使用ThreadPoolExecutor。

Spring框架提供了以Bean形式来配置线程池的ThreadPoolTaskExecutor类，ThreadPoolExecutor类的底层实现还是基于JDK的ThreadPoolExecutor。

# 示例代码
@Bean(name = "testExecutor")
public ThreadPoolTaskExecutor testExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    // 配置核心线程数
    executor.setCorePoolSize();
    // 配置最大线程数
    executor.setMaxPoolSize();
    // 配置队列大小
    executor.setQueueCapacity();
    executor.initialize();
    return executor;
}

2. 线程池拒绝策略

面试官：线程池请求队列满了，有新的请求进来怎么办？

大家如果有看ThreadPoolExecutor源码就知道，ThreadPoolExecutor类实现了setRejectedExecutionHandler方法，顾名思义意思是设置拒绝执行处理程序。

# ThreadPoolExecutor源码
/**
* Sets a new handler for unexecutable tasks. // 为无法执行的任务设置新的处理程序
*
* @param handler the new handler
* @throws NullPointerException if handler is null
* @see #getRejectedExecutionHandler
*/
public void setRejectedExecutionHandler(RejectedExecutionHandler handler) {
    if (handler == null)
        throw new NullPointerException();
    this.handler = handler;
}

该方法可以为线程池设置拒绝策略，目前JDK8一共有四种拒绝策略，也对应入参RejectedExecutionHandler的四种子类实现。

在这里插入图片描述

AbortPolicy：默认的拒绝策略，直接抛出RejectedExecutionException异常。
CallerRunsPolicy：直接在execute方法的调用线程中运行被拒绝的任务。
DiscardPolicy：直接丢弃被拒绝的任务。
DiscardOldestPolicy：丢弃最旧的未处理请求，然后重试execute 。

另外如果线程池拒绝策略设置为DiscardOldestPolicy，线程池的请求队列类型最好不要设置为优先级队列PriorityBlockingQueue。因为该拒绝策略是丢弃最旧的请求，也就意味着丢弃优先级最高的请求。

3. 线程工厂的作用

面试官：线程池的入参ThreadFactory有什么作用吗？

ThreadFactory定义了创建线程的工厂，回答这个问题我们就要结合实际场景了。

ThreadFactory线程工厂能够为线程池里每个线程设置名称、同时设置自定义异常的处理逻辑，可以方便我们通过日志来定位bug的位置。

以下是一个代码示例。

@Slf4j
public class CustomGlobalException {
    public static void main(String[] args) {
        ThreadFactory factory = r -> {
            String threadName = "线程名称";
            Thread thread = new Thread(r, threadName);
            thread.setUncaughtExceptionHandler((t, e) -> {
                log.error("{}执行了自定义异常日志", threadName);
            });
            return thread;
        };
        ExecutorService executor = new ThreadPoolExecutor(6,
                6,
                0,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(66),
                factory);

        executor.execute(() -> {
            throw new NullPointerException();
        });
        executor.shutdown();
    }
}

控制台打印：2024-04-26 22:04:45[ ERROR ]线程名称执行了自定义异常日志