线程池问题及答案(2024)

辞暮尔尔-烟火年年

已于 2024-01-31 11:39:52 修改

阅读量1.1k

点赞数 20

分类专栏：线程池复习面试专栏多线程文章标签： java java-ee 后端

于 2023-12-15 19:34:51 首次发布

本文链接：https://blog.youkuaiyun.com/qq_43012298/article/details/135023193

版权

多线程同时被 3 个专栏收录

82 篇文章

订阅专栏

复习面试专栏

56 篇文章

订阅专栏

线程池

7 篇文章

订阅专栏

1、什么是线程池？

线程池（Thread Pool）是一种基于池化思想管理线程的技术。在这种机制中，一定数量的线程被创建并保存在池中，准备执行任务。线程池可以有效地控制线程的数量，重复利用已有线程，减少了线程创建和销毁所带来的开销，提高了系统资源的利用率和系统的稳定性。

下面是线程池的一些关键特性和优点：

线程复用：线程池中的线程在执行完任务后不会消失，而是可以再次被用来执行新的任务，这样可以减少频繁创建和销毁线程的性能开销。
提高响应速度：当任务到达时，任务可以不需要等待线程的创建就能立即执行。
统一管理：线程池可以提供统一的点来分配、优化和监控线程资源。
线程数量控制：线程池能够限制系统中并发执行的线程数量，避免了大量线程之间竞争资源导致的性能下降。
提供任务队列：线程池一般都配有等待队列，可以在任务多于线程池中线程数量时，暂存任务。
灵活配置：线程池提供了多种参数设置，如核心线程数、最大线程数、线程存活时间等，以支持不同的应用需求。
减少资源消耗：通过重复利用线程，减少了线程创建和销毁的消耗，降低了系统的资源消耗。
提高系统稳定性：有效的线程数量控制可以防止因线程数过多导致内存溢出等问题，增加系统的稳定性。

线程池在处理大量短生命周期的异步任务时特别有用，比如在服务器应用程序中处理客户端的请求。Java中的java.util.concurrent包提供了一个强大的线程池实现，包括Executors类和ThreadPoolExecutor类。其他编程语言，如Python，也提供了类似的实现，如concurrent.futures模块中的ThreadPoolExecutor。

2、常见线程池

在Java中，线程池的创建和管理主要通过java.util.concurrent包中的Executor框架实现。Executor框架中的关键接口和类包括：

Executor: 这是一个基础接口，代表执行提交的Runnable任务的对象。
ExecutorService: 这是一个更高级的接口，它继承自Executor，添加了启动、关闭、提交任务等生命周期管理方法。
AbstractExecutorService: 这是ExecutorService的抽象实现，提供了大部分执行服务的基本实现。
ThreadPoolExecutor: 这是ExecutorService的一个具体实现，使用一个线程池执行任务，它是最灵活的线程池实现。
ScheduledExecutorService: 这个接口继承自ExecutorService，用于延迟执行或定期执行任务。
ScheduledThreadPoolExecutor: 这个类继承自ThreadPoolExecutor，实现ScheduledExecutorService，支持任务的定时和周期性执行。
Executors: 这是一个工厂和辅助类，提供了创建不同种类线程池的方法，包括：
- newFixedThreadPool(int nThreads): 创建一个固定线程数的线程池。
- newCachedThreadPool(): 创建一个根据需求自动调整线程数量的线程池。
- newSingleThreadExecutor(): 创建一个只有一个线程的线程池，保证所有提交的任务都顺序执行。
- newScheduledThreadPool(int corePoolSize): 创建一个可以调度命令在将来执行的线程池。
- newSingleThreadScheduledExecutor(): 创建一个只有一个线程，但支持任务调度的线程池。

每种类型的线程池都适用于不同的场景。例如，newFixedThreadPool适用于已知并发负载的应用场景，newCachedThreadPool适合执行许多短期异步任务的程序，而newSingleThreadExecutor适用于需要保证顺序执行任务的场景。

使用这些线程池时，开发者需要根据具体的应用场景和资源条件来选用最适合的线程池类型。同时，使用完线程池后，应该调用其shutdown()或shutdownNow()方法来关闭线程池，释放资源。

3、线程池参数

在Java的ThreadPoolExecutor类中，创建线程池时需要配置的核心参数包括：

corePoolSize:
- 核心线程数 —— 线程池中的线程数会保持在这个数量以上，即使有的线程处于空闲状态也不会被回收。
maximumPoolSize:
- 最大线程数 —— 线程池中允许的最大线程数量。当工作队列满了之后，线程池可以增加线程数，直到达到这个最大值。
keepAliveTime:
- 非核心线程空闲存活时间 —— 当线程池中的线程数量超过corePoolSize时，多余的空闲线程能够存活的时间。
unit:
- keepAliveTime的时间单位 —— 如毫秒、秒等，配合keepAliveTime参数使用。
workQueue:
- 任务队列 —— 用于保存等待执行的任务的阻塞队列。常用的队列如ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue等。
threadFactory:
- 线程工厂 —— 用于创建新线程的工厂。可以用默认的工厂，也可以提供一个ThreadFactory对象来自定义如何创建新线程。
handler:
- 拒绝策略 —— 当任务太多来不及处理，且工作队列已满，这时如果尝试将新的任务加入到线程池中将会执行拒绝策略。常见的拒绝策略有：ThreadPoolExecutor.AbortPolicy（抛出异常）、ThreadPoolExecutor.CallerRunsPolicy（用调用者所在的线程来执行任务）、ThreadPoolExecutor.DiscardPolicy（默默丢弃无法处理的任务，不予任何处理）、ThreadPoolExecutor.DiscardOldestPolicy（丢弃最早的未处理的任务请求）。

这些参数共同协作，决定了线程池的行为和性能。在实际应用中，应根据任务特性、系统资源以及性能要求合理配置这些参数。
在这里插入图片描述

4、线程池拒绝策略

在Java的ThreadPoolExecutor中，当线程池被耗尽并且工作队列也满了时，新提交的任务就会被拒绝。ThreadPoolExecutor提供了几种拒绝策略（RejectedExecutionHandler）：

AbortPolicy:
- 这是默认的拒绝策略。当任务被拒绝时，这个策略会抛出一个RejectedExecutionException异常。
CallerRunsPolicy:
- 这个策略不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。
DiscardPolicy:
- 这个策略将默默地丢弃被拒绝的任务，不做任何响应。
DiscardOldestPolicy:
- 这个策略将丢弃最早的未处理的任务请求，然后尝试再次提交当前任务（如果再次失败，依旧会丢弃任务，不会无限重试）。

选择合适的拒绝策略取决于具体的应用场景和需求。

例如，如果你希望即使在拒绝任务时也能保持系统的稳定性，CallerRunsPolicy可能是一个不错的选择，因为它会将负载压力分散到调用线程，而不是简单地抛出异常。

而如果任务是可以丢弃的，那么DiscardPolicy或者DiscardOldestPolicy可能更合适。

除了这些预定义的策略，你还可以通过实现RejectedExecutionHandler接口来创建自定义的拒绝策略，以满足特定应用的需求。

在这里插入图片描述

5、线程池状态

Java 线程池（ThreadPoolExecutor）有几种状态，这些状态定义在 ThreadPoolExecutor 类中，它们描述了线程池在生命周期中的不同阶段：

RUNNING(运行中):
- 线程池可以接受新任务，也可以处理阻塞队列中的任务。
- 线程池在创建时默认处于这个状态。
SHUTDOWN(关闭):
- 线程池不再接受新任务，但是可以处理存储在阻塞队列中的任务。
- 调用 shutdown() 方法会使线程池进入这个状态。
STOP(停止):
- 线程池不接受新任务，不处理阻塞队列中的任务，并且会中断正在处理的任务。
- 调用 shutdownNow() 方法会使线程池进入这个状态。
TIDYING(整理):
- 所有任务都已终止，workerCount（有效的工作线程数）为零，线程池的状态将转换到 TIDYING 状态。
- 线程池在转换到 TIDYING 状态时，会执行 terminated() 钩子方法。
TERMINATED(终止):
- terminated() 钩子方法已经运行完毕，线程池的状态就会变为 TERMINATED 状态。
- 线程池被完全终止，它不能再被使用。

在内部，这些状态是通过原子整数（AtomicInteger）来控制的，其中包含两部分信息：工作线程数量和运行状态。

ThreadPoolExecutor 使用位运算来同时管理这两类信息。

状态相关的常量（RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED）实际上是一些编码值，它们可以通过与当前线程池的控制状态进行逻辑运算来判断线程池当前的状态。

了解线程池的状态对于正确管理线程池资源和确保资源得到释放是很重要的。

例如，不应该向已经关闭（SHUTDOWN）的线程池提交任务，因为这样做会导致 RejectedExecutionException 异常。同样，了解线程池何时进入 TERMINATED 状态对于监控线程池的完全关闭也是必要的。

在这里插入图片描述

6、线程池工作流程

线程池的工作流程是指线程池管理和执行提交给它的任务的整个过程。理解这一流程对于有效地使用线程池至关重要。这里详细描述了线程池的典型工作流程：

初始化：
- 线程池在创建时，会初始化核心线程数（corePoolSize），但这些线程只有在有任务到来时才会创建。
任务提交：
- 当一个任务被提交给线程池时，会根据当前线程池的状态和任务队列的状态来决定下一步如何处理这个任务。
核心线程处理：
- 如果当前运行的线程数少于corePoolSize，线程池会创建一个新的线程（核心线程）来执行这个任务，即使可能有空闲的线程。
队列排队：
- 如果运行的线程数等于或超过了corePoolSize，任务将会被加入队列等待。队列通常是BlockingQueue的一个实例，用于存储等待执行的任务。
最大线程数限制：
- 如果队列已满，且当前运行的线程数还少于maximumPoolSize（最大线程数），线程池会尝试创建新的线程（非核心线程）来处理任务。
拒绝策略执行：
- 如果队列已满，并且当前运行的线程数已达到maximumPoolSize，线程池会根据其拒绝策略来处理无法执行的任务。
任务执行：
- 当线程可用时，队列中的任务将被移除并由线程执行。
线程闲置终止：
- 当一个线程没有任务执行时，它会等待一段指定的时间（keepAliveTime）。如果在等待时间结束后仍然没有新的任务，那么非核心线程将被终止，并从线程池中移除。核心线程默认情况下不会超时而被终止，除非设置了allowCoreThreadTimeOut为true。
线程池关闭：
- 线程池可以通过shutdown()方法来平滑地关闭。这种情况下，线程池不再接受新任务，但已经提交的任务会继续执行。
- shutdownNow()方法会尝试立即关闭线程池，并尽力停止正在执行的任务，返回那些尚未开始执行的任务列表。
任务完成：
- 线程池中的所有任务完成后，如果线程池已关闭，那么其中的所有线程都会最终终止。

这个流程描述的是最常见的线程池实现，特别是在Java中java.util.concurrent.ThreadPoolExecutor的行为。不同的线程池实现可能会在某些细节上有所不同，但大体上都遵循这样的流程模式。
在这里插入图片描述

在这里插入图片描述

7、如何合理配置线程池大小

合理配置线程池大小是非常关键的，因为它直接影响到应用程序的性能和系统资源的利用率。线程池太大会消耗过多的内存，增加上下文切换的开销；线程池太小又可能导致处理器资源未能得到充分利用，引发性能瓶颈。确定线程池的正确大小，应当考虑以下几个因素：

1. 任务的性质

CPU密集型任务（计算密集型）：这类任务需要大量的计算，而不是大量的等待。对于CPU密集型任务，线程池大小应接近处理器的可用物理核心数。一个常见的策略是设置线程池的大小为 处理器数量 + 1，这样即使线程在某一刻由于页错或其他原因被暂停，额外的线程也可以确保CPU周期不会浪费。
IO密集型任务：如果任务涉及到文件处理、网络通信等待，那么它们在执行期间会有大量的阻塞时间。在这种情况下，线程池可以设置得相对较大，因为线程在等待I/O完成时不会使用CPU。对于IO密集型任务，线程池大小通常设置为 处理器数量 * (1 + 平均等待时间 / 平均工作时间)，但实际值通常由性能测试确定。

2. 系统的资源

系统资源如CPU、内存等也影响着线程池的大小。一个过大的线程池可能会消耗太多的内存，这会影响系统的性能。

3. 任务的执行时间

如果提交到线程池中的任务执行时间较短，则线程池不需要太大，因为线程切换的开销不会太大。但如果任务执行时间较长，那么可能需要更多的线程来确保有足够的并发性。

4. 任务的到达率

如果任务提交到线程池的速度相对较快，并且每个任务处理的时间不是很长，线程池大小需要较大以避免队列中的任务积压。

具体配置方法：

在实际配置线程池时，通常通过以下步骤：

benchmarking: 执行基准测试，了解不同线程池大小对应用程序性能的影响。
监控系统资源: 使用系统监控工具观察不同线程池配置下，系统的CPU、内存使用率以及线程状态。
调整和重复: 根据监测结果调整线程池大小，并重复测试，直到找到性能最优的值。

实践策略：

限制队列长度：有时候可以通过限制任务队列的长度来自动调整线程池的大小。
拒绝策略：定义线程池饱和时任务的拒绝策略。
动态调整：部分高级线程池实现支持动态调整线程的数量。

示例：

这是一个基于Java平台的线程池大小配置示例。在Java中，可以使用Runtime.getRuntime().availableProcessors()获取可用的处理器数量来帮助配置线程池：

// CPU密集型任务时
int numberOfCores = Runtime.getRuntime().availableProcessors();
ExecutorService cpuIntensiveThreadPool = Executors.newFixedThreadPool(numberOfCores + 1);

// IO密集型任务时, 假设IO操作大约需要10倍于CPU计算时间
float blockingCoefficient = 0.9f; // 在计算时block的比例假设为90%
int poolSize = (int)(numberOfCores / (1 - blockingCoefficient));
ExecutorService ioIntensiveThreadPool = Executors.newFixedThreadPool(poolSize);

上述示例简化了线程池配置的计算，但实际应用中通常需要通过实际负载和性能测试来确定最佳配置。如果系统是多租户的或运行多个应用程序，那么线程池的配置可能需要更加谨慎，以避免一个贪婪的应用程序消耗所有的线程资源。

8、线程池中提交任务的方式有哪些

在线程池中提交任务通常有两种方式：执行 Runnable 任务和提交 Callable 任务。这两种方式在 Java 的 ExecutorService 接口中分别由 execute() 和 submit() 方法提供。下面是对这些方法的详细说明和比较。

1. 执行 Runnable 任务：

Runnable 接口是执行任务的简单方法，其中的 run() 方法不返回任何结果。

execute(Runnable command)
方法签名：void execute(Runnable command)
描述：用来提交不需要任何返回结果的任务。如果线程池无法接受任务，可能会抛出一个 RejectedExecutionException。当任务出现异常时，异常会被线程池中的未捕获异常处理器(UncaughtExceptionHandler)处理，任务也会终止执行，但不会影响线程池中其它任务的执行。

2. 提交 Callable 任务：

Callable 接口类似于 Runnable，但它的 call() 方法有返回值，并且能抛出异常。

submit(Callable task)
方法签名：<T> Future<T> submit(Callable<T> task)
描述：使用此方法提交需要返回结果的任务。submit 方法会返回一个 Future 对象，该对象可以用来检查任务是否已经完成，以及等待任务完成后获取其结果。
submit(Runnable task, T result)
方法签名：<T> Future<T> submit(Runnable task, T result)
描述：此重载的 submit 方法允许提交 Runnable 任务，并在任务完成时获得一个预先设定的结果。可以通过返回的 Future 获取这个结果。
submit(Runnable task)
方法签名：Future<?> submit(Runnable task)
描述：此重载版本允许提交 Runnable 任务，并且返回一个 Future 对象。与 execute() 方法不同，即便 Runnable 任务没有返回值，仍然可以通过 Future 对象查询任务是否完成或等待任务结束。

3. 其他任务提交方式：

除了 execute() 和 submit() 方法，ExecutorService 还提供了其他方法来批量提交任务，例如 invokeAny() 和 invokeAll()：

invokeAll(Collection<? extends Callable> tasks)
方法签名：<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException
描述：提交一个任务集合，等待所有任务执行完成。
invokeAny(Collection<? extends Callable> tasks)
方法签名：<T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException
描述：提交一个任务集合，并且返回其中一个成功完成的任务的结果（取第一个执行完成的任务的结果，其他未完成的任务将被取消）。

执行与提交的区别：

异常处理
使用 execute() 提交的任务，异常将被线程的 UncaughtExceptionHandler 处理，而 submit() 返回的 Future 允许用户通过 Future.get() 方法来捕获和处理异常。
返回值获取
对于需要返回值的任务，应该使用 submit() 方法。如果不需要返回值，有时 execute() 是更好的选择，因为它的概念更简单直接。
任务控制
submit() 返回的 Future 对象提供了更多控制，例如取消执行、查询任务完成情况等。

示例：

以下是 Java 中使用线程池提交任务的示例：

import java.util.concurrent.*;

public class ThreadPoolDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // 提交 Runnable 任务，没有返回值
        executor.execute(() -> System.out.println("Runnable executed"));

        // 提交 Callable 任务，有返回值
        Future<String> future = executor.submit(() -> "Callable result");

        // 使用 future.get() 阻塞和等待 Callable 任务执行完成，并获取结果
        String result = future.get();  // 获取执行结果
        System.out.println(result);

        executor.shutdown(); // 关闭线程池
    }
}

在线程池和并发编程中，明确任务的类型和控制需求是选择执行方法的关键。无论哪种方式，任务执行后应该始终保证线程池资源的正确关闭和释放。

9、在实际项目中为什么不推荐Executors创建的线程池

在实际项目中，通常不推荐使用 java.util.concurrent.Executors 类的静态方法创建线程池，主要原因是由这些方法创建的线程池存在资源管理上的问题，这些问题可能导致系统性能降低，甚至出现内存溢出等更严重的问题。以下是几个不推荐使用 Executors 创建线程池的具体原因：

1. `FixedThreadPool` 和 `SingleThreadExecutor`:

Executors.newFixedThreadPool(int) 和 Executors.newSingleThreadExecutor() 方法创建的线程池具有无界队列（LinkedBlockingQueue），这意味着理论上队列可以无限增长。当实际任务提交速度超过线程池处理速度，队列会持续积压，可能导致内存溢出。

ExecutorService executor = Executors.newFixedThreadPool(10); // 创建拥有无界队列的固定大小线程池

2. `CachedThreadPool` 和 `ScheduledThreadPoolExecutor`:

Executors.newCachedThreadPool() 创建的线程池允许创建无限多线程，并且当线程闲置60秒后会自动被回收。在高负载情况下，这可能会创建大量线程，耗尽系统资源，导致CPU过载和系统不稳定。

ExecutorService executor = Executors.newCachedThreadPool(); // 创建可缓存线程池，可能创建无限多线程

Executors.newScheduledThreadPool() 的默认实现也具有类似于 CachedThreadPool 的问题。

3. 默认的拒绝策略和线程工厂:

使用 Executors 创建的线程池都是使用默认的线程工厂和默认的拒绝执行处理程序。在实际项目中，可能需要自定义这些设置以更好地控制线程创建和拒绝策略，比如在拒绝任务时进行日志记录或者提供回调处理。

4. 易于错误配置:

Executors 的方便性往往掩盖了潜在的配置问题，开发人员可能未能考虑到高负载下可能会出现的问题，也可能无法调整默认配置以满足特定场景的要求。

10、使用线程池时我们需要注意什么

在使用线程池时，应当注意以下关键点，以确保线程池可以高效且安全地工作：

正确配置线程池参数：
- 根据任务的特性（CPU密集型、IO密集型或混合型）和服务器的硬件能力来合理设置corePoolSize（核心线程数）、maximumPoolSize（最大线程数）、keepAliveTime（非核心线度空闲存活时间）和workQueue（工作队列）。
使用合适的工作队列：
- 根据任务的执行情况选择合适的队列类型，如有界队列（ArrayBlockingQueue）、无界队列（LinkedBlockingQueue）、优先级队列（PriorityBlockingQueue）等。
合理选择拒绝策略：
- 根据任务的重要性和系统容错性要求选择合适的拒绝策略，如AbortPolicy、CallerRunsPolicy、DiscardPolicy、DiscardOldestPolicy，或实现自定义拒绝策略。
资源的合理分配和监控：
- 监控线程池的使用情况，及时发现可能的性能瓶颈或配置问题，并根据实际情况调整配置。
优雅关闭线程池：
- 在应用程序关闭或重新加载时，应该先尝试平滑关闭线程池（使用shutdown()或shutdownNow()），避免执行中的任务被突然中断。
避免任务间的相互阻塞：
- 确保线程池中的任务不会互相等待结果，导致死锁。
处理好线程任务的异常：
- 在任务执行过程中可能会抛出运行时异常，应适当处理异常，避免因为异常导致线程意外终止。
避免创建大量短生命周期的线程池：
- 频繁地创建和销毁线程池会增加不必要的开销。在可能的情况下，复用线程池或者使用线程池工厂。
避免任务过长执行时间：
- 任务执行时间过长会占用线程过久，导致线程池中的其他任务无法及时处理。应该尽量使任务简短，或者考虑将大任务分解为多个小任务。
不要忽视线程池的异常和日志：
- 对线程池的运行异常和性能进行记录和监控，以便于出现问题时能够迅速定位和解决。

通过注意以上这些细节，你可以更有效地使用线程池来提高程序的并发能力和性能表现。

11、实际开发中为什么推荐自定义线程池？

在实际开发中推荐自定义线程池，原因是多方面的。默认线程池（如通过 Executors 类创建的线程池）通常提供的配置无法满足全部场景，且某些默认设置可能会导致资源浪费或者应用崩溃。下面提供一些深入和详细的理由：

1. 避免默认线程池的局限性

Executors.newFixedThreadPool() 创建的固定大小的线程池使用了无界队列，这可能导致在任务增加时无限制地增加队列大小，从而耗尽内存。
Executors.newCachedThreadPool() 创建的缓存线程池允许创建数量几乎无限的线程，高负载下可能导致创建过多线程，耗尽CPU和内存资源。
Executors.newSingleThreadExecutor() 和 Executors.newScheduledThreadPool() 同样使用无界队列，可能导致资源耗尽。

2. 资源优化和调整

使用自定义线程池可以针对应用的需求精细地调整线程池的参数，例如：

核心线程数（Core Pool Size）：基于应用的工作负载，你可以决定最适合的核心线程数，避免资源的浪费。
最大线程数（Maximum Pool Size）：限制最大线程数可以避免过多的线程竞争资源。
Keep-Alive Time：合理配置线程的存活时间可以避免线程存在的时间过长或过短。
工作队列大小：有界队列可以帮助你控制任务积压的风险，从而避免OOM（Out of Memory）错误。

3. 明确的拒绝策略

自定义线程池允许你设置明确的拒绝策略应对超负荷的情况，如 CallerRunsPolicy（调用者运行策略）， AbortPolicy（抛出异常），DiscardPolicy（放弃任务），或是 DiscardOldestPolicy（放弃队列中最旧的任务）等。

4. 线程工厂的自定义

自定义 ThreadFactory 允许你创建具有意义的线程名称，这在进行问题分析和调试时非常有帮助。此外，自定义 ThreadFactory 还能设置线程的优先级、守护状态等。

5. 结合监控和管理

通过自定义线程池的使用，可以更方便地加入监控和管理代码，比如跟踪线程池中当前活动线程的数量，队列中的任务数量等，实现线程池的动态管理和调整。

6. 更好的异常管理

默认线程池中，未捕获的异常会导致线程直接终止并被线程池移除，新的任务也许无法执行。自定义线程池允许你提供 UncaughtExceptionHandler 来捕获和处理这些异常。

7. 提升系统健壮性

正确配置的线程池有助于平衡负载，同时提高系统的可伸缩性和响应性。它可以在负载增加时适应性地扩展，而在闲暇时收缩，从而提升系统资源的使用效率。

示例

以下是一个简单示例展示了如何创建自定义线程池：

int corePoolSize = 10;
int maximumPoolSize = 20;
long keepAliveTime = 1;
TimeUnit timeUnit = TimeUnit.MINUTES;
BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(50);

ThreadFactory threadFactory = new MyCustomThreadFactory();
RejectedExecutionHandler rejectionHandler = new ThreadPoolExecutor.AbortPolicy();

ExecutorService threadPool = new ThreadPoolExecutor(
    corePoolSize,
    maximumPoolSize,
    keepAliveTime,
    timeUnit,
    workQueue,
    threadFactory,
    rejectionHandler
);