前言
在 Java 并发编程领域，线程池是一个绕不开的核心技术点。无论是高并发的互联网应用，还是后台服务系统，线程池都扮演着至关重要的角色。它不仅能够有效管理线程资源，避免线程频繁创建与销毁带来的性能开销，还能对并发任务进行合理调度，保障系统的稳定性与高效性。然而，很多开发者在实际使用线程池时，往往只停留在 “拿来即用” 的层面，对其底层原理、参数配置以及常见问题缺乏深入理解，导致在高并发场景下出现各种性能瓶颈或线程安全问题。本文将从线程池的核心原理出发，详细讲解线程池的参数配置、工作流程、使用示例以及常见问题解决方案，帮助开发者全面掌握 Java 线程池技术，写出更高效、更稳定的并发代码。
一、为什么需要线程池？
在了解线程池的具体实现之前，我们首先要搞清楚一个问题：为什么需要线程池？直接创建线程来处理任务不可以吗？
1.1 线程创建与销毁的开销
在 Java 中，创建一个线程需要调用操作系统的 API，涉及到用户态与内核态的切换，这个过程是比较耗时的。同时，线程在运行结束后，还需要进行销毁操作，释放占用的内存、CPU 等资源。如果在高并发场景下，每次处理任务都创建一个新线程，任务执行完成后再销毁线程，那么线程的创建与销毁开销将占据大量的系统资源，严重影响系统的性能。
例如，假设一个任务的执行时间为 1ms，而创建和销毁线程的时间为 10ms，那么在处理 1000 个任务时，线程创建与销毁的总时间就达到了 10000ms，远大于任务实际执行的总时间 1000ms。这种情况下，系统的大部分时间都浪费在了线程的创建与销毁上，任务的处理效率极低。
1.2 线程数量的失控风险
如果不使用线程池，而是随意创建线程，很容易导致线程数量失控。当并发任务数量非常多时，系统会创建大量的线程，每个线程都会占用一定的内存空间（默认情况下，Java 线程的栈内存大小为 1MB）。当线程数量达到一定规模后，会导致系统内存耗尽，进而引发 OutOfMemoryError 异常。此外，大量的线程还会导致 CPU 频繁进行上下文切换，上下文切换会消耗大量的 CPU 资源，使得 CPU 的利用率大幅下降，系统的响应速度变慢。
1.3 线程池的优势
相比直接创建线程，线程池具有以下显著优势：
- 资源复用：线程池中的线程可以重复使用，避免了线程频繁创建与销毁带来的性能开销。当有新任务到达时，直接使用线程池中的空闲线程进行处理，任务执行完成后，线程不会被销毁，而是回到线程池中等待下一个任务。
- 线程数量控制：线程池可以对线程的数量进行严格控制，通过设置核心线程数、最大线程数等参数，避免线程数量失控，防止系统资源被过度消耗。
- 任务队列缓冲：线程池通常会搭配一个任务队列，当线程池中的所有核心线程都在忙碌时，新到达的任务会被放入任务队列中进行缓冲，等待空闲线程来处理。这样可以避免任务因无法及时处理而被丢弃，提高任务的处理成功率。
- 提供丰富的功能扩展：Java 中的 ThreadPoolExecutor 类提供了丰富的钩子方法（如 beforeExecute、afterExecute、terminated 等），开发者可以通过重写这些方法来实现自定义的任务处理逻辑，如任务执行前后的日志记录、线程池关闭时的资源清理等。
二、Java 线程池的核心原理
Java 中的线程池主要是通过java.util.concurrent.ThreadPoolExecutor类来实现的，掌握 ThreadPoolExecutor 的核心原理是理解 Java 线程池的关键。
2.1 ThreadPoolExecutor 的构造方法
ThreadPoolExecutor 类提供了多个重载的构造方法，其中最核心的构造方法如下：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
这个构造方法包含了 7 个核心参数，每个参数都对线程池的工作行为有着重要影响，下面我们逐一介绍这些参数的含义：
2.1.1 corePoolSize（核心线程数）
核心线程数是线程池中长期保持的线程数量，即使这些线程处于空闲状态，也不会被销毁（除非设置了allowCoreThreadTimeOut为 true）。当有新任务到达时，线程池会首先尝试创建核心线程来处理任务。如果核心线程数尚未达到设置的最大值，线程池会创建新的核心线程；如果核心线程数已经达到最大值，新任务会被放入任务队列中等待。
2.1.2 maximumPoolSize（最大线程数）
最大线程数是线程池能够创建的线程数量的上限。当任务队列已满，且核心线程数已经达到 corePoolSize 时，线程池会创建非核心线程来处理任务，直到线程的总数量达到 maximumPoolSize。如果线程的总数量已经达到 maximumPoolSize，且任务队列也已满，此时新到达的任务会被拒绝处理，线程池会调用拒绝策略来处理这些任务。
2.1.3 keepAliveTime（非核心线程空闲存活时间）
非核心线程在空闲状态下的存活时间。当线程池中的线程数量超过 corePoolSize 时，多余的非核心线程在空闲了 keepAliveTime 时间后，会被销毁，以释放系统资源。需要注意的是，这个参数只对非核心线程有效。如果通过allowCoreThreadTimeOut(true)将核心线程的空闲存活时间也设置为 keepAliveTime，那么核心线程在空闲了相应时间后也会被销毁。
2.1.4 unit（时间单位）
keepAliveTime 参数的时间单位，取值来源于java.util.concurrent.TimeUnit枚举类，常见的取值有 TimeUnit.SECONDS（秒）、TimeUnit.MILLISECONDS（毫秒）、TimeUnit.MINUTES（分钟）等。
2.1.5 workQueue（任务队列）
用于存放等待执行任务的阻塞队列。当线程池中的核心线程都在忙碌时，新到达的任务会被放入任务队列中。任务队列的选择对线程池的性能有着重要影响，Java 中提供了多种阻塞队列可供选择，常见的有：
- ArrayBlockingQueue：基于数组实现的有界阻塞队列，按照 FIFO（先进先出）的原则对任务进行排序。使用 ArrayBlockingQueue 时，必须指定队列的容量大小。
- LinkedBlockingQueue：基于链表实现的阻塞队列，同样按照 FIFO 的原则排序。它可以是有界的，也可以是无界的（默认情况下是无界的，容量为 Integer.MAX_VALUE）。由于默认是无界的，当任务数量非常多时，可能会导致内存溢出，因此在实际使用时，建议指定队列的容量。
- SynchronousQueue：一个不存储任务的阻塞队列。当线程池使用 SynchronousQueue 作为任务队列时，每次提交任务都必须有一个空闲线程来处理任务，否则就会创建新的线程（直到达到 maximumPoolSize）。SynchronousQueue 通常用于需要快速处理任务的场景，如缓存线程池（Executors.newCachedThreadPool ()）。
- PriorityBlockingQueue：基于优先级排序的无界阻塞队列。任务会按照优先级的高低进行排序，优先级高的任务会被优先执行。PriorityBlockingQueue 的默认排序方式是自然排序，也可以通过实现 Comparator 接口来自定义任务的排序规则。
2.1.6 threadFactory（线程工厂）
用于创建线程的工厂类。通过 threadFactory，我们可以自定义线程的名称、优先级、是否为守护线程等属性。默认情况下，线程池使用Executors.defaultThreadFactory()作为线程工厂，创建的线程名称格式为 “pool-xxx-thread-xxx”，优先级为 Thread.NORM_PRIORITY，且为非守护线程。在实际开发中，自定义线程工厂可以方便我们对线程进行管理和监控，例如通过线程名称来区分不同业务模块的线程。
下面是一个自定义线程工厂的示例：
public class CustomThreadFactory implements ThreadFactory {
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
public CustomThreadFactory(String namePrefix) {
this.namePrefix = namePrefix + "-thread-";
}
@Override
public Thread newThread(Runnable r) {
Thread thread = new Thread(r, namePrefix + threadNumber.getAndIncrement());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
return thread;
}
}
2.1.7 RejectedExecutionHandler（拒绝策略）
当线程池的线程数量达到 maximumPoolSize，且任务队列也已满时，新提交的任务会被拒绝处理，此时线程池会调用拒绝策略来处理这些被拒绝的任务。Java 中提供了四种默认的拒绝策略，分别定义在java.util.concurrent.ThreadPoolExecutor类中：
- AbortPolicy（默认）：直接抛出RejectedExecutionException异常，阻止系统正常运行。这种策略适用于任务非常重要，不允许丢失的场景，通过抛出异常可以及时发现问题并进行处理。
- CallerRunsPolicy：由提交任务的调用者线程来执行被拒绝的任务。这种策略可以降低任务的提交速度，缓解线程池的压力，但会影响调用者线程的执行效率。
- DiscardPolicy：直接丢弃被拒绝的任务，不做任何处理，也不抛出异常。这种策略适用于任务无关紧要，丢失几个任务对系统没有影响的场景。
- DiscardOldestPolicy：丢弃任务队列中最旧的未处理任务，然后将新提交的任务放入任务队列中。这种策略适用于任务具有一定的时效性，旧任务的价值较低的场景。
除了上述四种默认的拒绝策略外，开发者还可以通过实现RejectedExecutionHandler接口来自定义拒绝策略，例如将被拒绝的任务记录到日志中，或者将任务保存到数据库中，以便后续进行重试。
2.2 线程池的工作流程
理解了 ThreadPoolExecutor 的核心参数后，我们再来梳理一下线程池的工作流程。当一个新的任务被提交到线程池时，线程池会按照以下步骤进行处理：
- 判断核心线程是否空闲：线程池首先会检查核心线程池（核心线程的数量为 corePoolSize）中的线程是否有空闲。如果有空闲核心线程，就会调用该核心线程来执行新提交的任务。
- 核心线程已满，判断任务队列是否已满：如果核心线程池中的所有核心线程都在忙碌，线程池会检查任务队列（workQueue）是否已满。如果任务队列未满，就会将新提交的任务放入任务队列中，等待空闲线程来处理。
- 任务队列已满，判断是否达到最大线程数：如果任务队列已满，线程池会检查当前线程池中的线程总数是否已经达到 maximumPoolSize。如果尚未达到，就会创建新的非核心线程来执行新提交的任务。
- 达到最大线程数，执行拒绝策略：如果当前线程池中的线程总数已经达到 maximumPoolSize，且任务队列也已满，此时新提交的任务会被拒绝处理，线程池会调用预先设置的拒绝策略（RejectedExecutionHandler）来处理这些被拒绝的任务。
为了更直观地理解线程池的工作流程，我们可以用一个流程图来表示：
新任务提交
↓
核心线程池是否有空闲线程？
↓ 是
使用空闲核心线程执行任务
↓ 否
任务队列是否已满？
↓ 否
将任务放入任务队列等待
↓ 是
当前线程总数是否达到maximumPoolSize？
↓ 否
创建非核心线程执行任务
↓ 是
执行拒绝策略
三、Java 线程池的使用示例
在 Java 中，除了直接使用 ThreadPoolExecutor 类来创建线程池外，java.util.concurrent.Executors工具类还提供了多个静态方法来快速创建线程池，常见的有：
- Executors.newFixedThreadPool(int nThreads)：创建一个固定核心线程数和最大线程数的线程池，任务队列使用 LinkedBlockingQueue（无界）。
- Executors.newCachedThreadPool()：创建一个可缓存的线程池，核心线程数为 0，最大线程数为 Integer.MAX_VALUE，任务队列使用 SynchronousQueue，非核心线程的空闲存活时间为 60 秒。
- Executors.newSingleThreadExecutor()：创建一个只有一个核心线程的线程池，最大线程数也为 1，任务队列使用 LinkedBlockingQueue（无界），所有任务都由同一个线程按照 FIFO 的顺序执行。
- Executors.newScheduledThreadPool(int corePoolSize)：创建一个可以定时或周期性执行任务的线程池，核心线程数为指定的 corePoolSize，最大线程数为 Integer.MAX_VALUE。
然而，在阿里巴巴 Java 开发手册中，明确禁止使用 Executors 工具类创建线程池，主要原因是：
- newFixedThreadPool和newSingleThreadExecutor使用的是无界的 LinkedBlockingQueue，当任务数量非常多时，任务队列会不断积累任务，导致内存溢出。
- newCachedThreadPool和newScheduledThreadPool的最大线程数为 Integer.MAX_VALUE，当任务数量过多时，会创建大量的线程，导致线程数量失控，引发内存溢出或 CPU 上下文切换频繁的问题。
因此，在实际开发中，建议直接使用 ThreadPoolExecutor 类来创建线程池，通过合理配置核心参数，避免上述问题。下面我们将通过几个示例来介绍线程池的具体使用方法。
3.1 基本使用示例
下面是一个使用 ThreadPoolExecutor 创建线程池，并提交任务的基本示例：
import java.util.concurrent.*;
public class ThreadPoolExample {
public static void main(String[] args) {
// 1. 自定义线程工厂
ThreadFactory threadFactory = new CustomThreadFactory("order-process");
// 2. 创建任务队列（有界队列，容量为100）
BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue00);
// 3. 定义拒绝策略（自定义拒绝策略，记录日志）
RejectedExecutionHandler rejectedHandler = (r, executor) -> {
System.out.println("任务" + r.toString() + "被拒绝，线程池当前状态：" + executor.toString());
// 可以在这里添加日志记录、任务持久化等逻辑
};
// 4. 创建线程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
5, // 核心线程数
10, // 最大线程数
60, // 非核心线程空闲存活时间
TimeUnit.SECONDS, // 时间单位
workQueue, // 任务队列
threadFactory, // 线程工厂
rejectedHandler // 拒绝策略
);
// 5. 提交100个任务到线程池
for (int i = 0; i 00; i++) {
int taskId = i;
threadPool.submit(() -> {
try {
// 模拟任务执行时间（100ms）
Thread.sleep(100);
System.out.println("任务" + taskId + "执行完成，执行线程：" + Thread.currentThread().getName());
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
e.printStackTrace();
}
});
}
// 6. 关闭线程池（平缓关闭，等待所有任务执行完成后再关闭）
threadPool.shutdown();
// 等待线程池关闭
try {
if (!threadPool.awaitTermination(60, TimeUnit.SECONDS)) {
// 超时后强制关闭线程池
threadPool.shutdownNow();
if (!threadPool.awaitTermination(60, TimeUnit.SECONDS)) {
System.out.println("线程池无法正常关闭");
}
}
} catch (InterruptedException e) {
threadPool.shutdownNow();
Thread.currentThread().interrupt();
e.printStackTrace();
}
System.out.println("线程池已关闭");
}
// 自定义线程工厂
static class CustomThreadFactory implements ThreadFactory {
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
public CustomThreadFactory(String namePrefix) {
this.namePrefix = namePrefix + "-thread-";
}
@Override
public Thread newThread(Runnable r) {
Thread thread = new Thread(r, namePrefix + threadNumber.getAndIncrement());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
return thread;
}
}
}
在这个示例中，我们首先自定义了线程工厂和拒绝策略，然后创建了一个核心线程数为 5、最大线程数为 10、任务队列为有界 ArrayBlockingQueue（容量 100）的线程池。接着，我们向线程池提交了 100 个任务，每个任务模拟执行 100ms。最后，我们调用shutdown()方法平缓关闭线程池，并通过awaitTermination()方法等待线程池关闭，确保所有任务都能执行完成。
3.2 定时任务线程池示例
除了处理普通的异步任务外，线程池还可以用于执行定时任务或周期性任务。Java 中的ScheduledThreadPoolExecutor类是 ThreadPoolExecutor 的子类，专门用于执行定时任务。下面是一个使用 ScheduledThreadPoolExecutor 执行定时任务的示例：
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduledThreadPoolExample {
public static void main(String[] args) {
// 创建一个核心线程数为2的定时任务线程池
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);
// 1. 延迟1秒后执行一次任务
System.out.println("提交延迟任务的时间：" + System.currentTimeMillis());
scheduledThreadPool.schedule(() -> {
System.out.println("延迟任务执行时间：" + System.currentTimeMillis());
System.out.println("延迟任务执行完成");
}, 1, TimeUnit.SECONDS);
// 2. 延迟2秒后，每隔3秒执行一次任务（固定延迟执行）
System.out.println("提交固定延迟任务的时间：" + System.currentTimeMillis());
scheduledThreadPool.scheduleWithFixedDelay(() -> {
try {
// 模拟任务执行时间（1秒）
Thread.sleep(1000);
System.out.println("固定延迟任务执行时间：" + System.currentTimeMillis());
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
e.printStackTrace();
}
}, 2, 3, TimeUnit.SECONDS);
// 3. 延迟3秒后，每隔3秒执行一次任务（固定速率执行）
System.out.println("提交固定速率任务的时间：" + System.currentTimeMillis());
scheduledThreadPool.scheduleAtFixedRate(() -> {
try {
// 模拟任务执行时间（1秒）
Thread.sleep(1000);
System.out.println("固定速率任务执行时间：" + System.currentTimeMillis());
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
e.printStackTrace();
}
}, 3, 3, TimeUnit.SECONDS);
// 等待一段时间后关闭线程池（避免主线程提前退出）
try {
Thread.sleep(20000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
e.printStackTrace();
}
scheduledThreadPool.shutdown();
System.out.println("定时任务线程池已关闭");
}
}
在这个示例中，我们使用Executors.newScheduledThreadPool(2)创建了一个核心线程数为 2 的定时任务线程池，并演示了三种定时任务的执行方式：
- schedule(Runnable command, long delay, TimeUnit unit)：延迟指定时间后执行一次任务。
- scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)：延迟 initialDelay 时间后，每隔 delay 时间执行一次任务。这里的 delay 是指前一次任务执行完成到后一次任务开始执行的时间间隔。
- scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)：延迟 initialDelay 时间后，每隔 period 时间执行一次任务。这里的 period 是指两次任务开始执行的时间间隔，如果前一次任务执行时间超过 period，那么后一次任务会在前一次任务执行完成后立即执行。
四、线程池的常见问题与解决方案
在使用线程池的过程中，我们经常会遇到一些问题，如线程池参数配置不合理、任务执行异常、线程池关闭不当等。下面我们将介绍这些常见问题，并给出相应的解决方案。
4.1 线程池参数配置不合理
线程池的参数配置（如核心线程数、最大线程数、任务队列容量等）直接影响线程池的性能。如果参数配置不合理，可能会导致线程池的处理效率低下，甚至引发系统故障。
4.1.1 核心线程数与最大线程数的配置
核心线程数和最大线程数的配置需要根据任务的类型和系统资源来确定。一般来说，任务可以分为 CPU 密集型任务和 IO 密集型任务，不同类型的任务对线程数的需求不同：
- CPU 密集型任务：这类任务主要消耗 CPU 资源，如复杂的计算、数据处理等。由于 CPU 的核心数量是有限的，过多的线程会导致 CPU 频繁进行上下文切换，降低 CPU 的利用率。因此，对于 CPU 密集型任务，核心线程数和最大线程数建议设置为 CPU 核心数 + 1。这样既可以充分利用 CPU 资源，又可以避免过多的上下文切换。
- IO 密集型任务：这类任务主要涉及 IO 操作（如数据库读写、网络请求等），在 IO 操作期间，线程会处于阻塞状态，CPU 会处于空闲状态。因此，对于 IO 密集型任务，可以设置更多的线程来提高 CPU 的利用率。核心线程数和最大线程数建议设置为 CPU 核心数 * 2。如果 IO 操作的等待时间较长，还可以适当增加线程数。
当然，上述只是一个参考值，在实际配置时，还需要结合系统的实际情况进行调整。例如，可以通过压测工具（如 JMeter、LoadRunner）对系统进行压测，观察不同线程数下系统的吞吐量、响应时间等指标，从而确定最优的线程数配置。
4.1.2 任务队列的配置
任务队列的选择和容量配置也非常重要。对于有界队列和无界队列，需要根据业务场景进行选择：
- 如果任务的处理速度较慢，且任务数量可能非常多，建议使用有界队列，并合理设置队列容量。这样可以避免任务队列无限增长导致内存溢出。同时，需要搭配合适的拒绝策略，当队列已满时，及时处理被拒绝的任务。
- 如果任务的处理速度较快，且任务数量相对较少，或者任务不允许丢失，可以考虑使用无界队列。但需要注意监控任务队列的长度，避免任务堆积过多。
4.2 任务执行异常未处理
在线程池中执行的任务，如果发生了未捕获的异常，会导致线程终止，并且线程池会创建新的线程来替代这个终止的线程。如果任务执行异常的频率较高，会导致线程频繁创建与销毁，增加系统的性能开销。此外，未处理的异常还可能导致业务逻辑错误，影响系统的正常运行。
解决方案
- 在任务内部捕获异常：在提交到线程池的任务中，尽量在 run () 方法或 call () 方法内部捕获所有可能的异常，并进行相应的处理（如记录日志、重试任务等）。例如：
threadPool.submit(() -> {
try {
// 任务执行逻辑
doTask();
} catch (Exception e) {
// 记录异常日志
log.error("任务执行异常", e);
// 根据业务需求决定是否重试任务
if (needRetry()) {
retryTask();
}
}
});
- 使用 Future 获取任务执行结果：如果使用submit()方法提交任务（而不是execute()方法），可以通过Future对象获取任务的执行结果，包括任务执行过程中抛出的异常。例如：
Future<?> future = threadPool.submit(() -> {
// 任务执行逻辑，可能会抛出异常
doTask();
});
try {
// 获取任务执行结果，如果任务执行过程中抛出异常，get()方法会将异常封装为ExecutionException抛出
future.get();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
log.error("任务执行被中断", e);
} catch (ExecutionException e) {
log.error("任务执行异常", e.getCause());
// 处理异常
}
- 自定义线程工厂，设置未捕获异常处理器：可以通过自定义线程工厂，为线程池中的每个线程设置未捕获异常处理器（UncaughtExceptionHandler），当线程执行任务发生未捕获异常时，由未捕获异常处理器进行处理。例如：
public class CustomThreadFactory implements ThreadFactory {
// ... 其他代码 ...
@Override
public Thread newThread(Runnable r) {
Thread thread = new Thread(r, namePrefix + threadNumber.getAndIncrement());
// 设置未捕获异常处理器
thread.setUncaughtExceptionHandler((t, e) -> {
log.error("线程" + t.getName() + "执行任务发生未捕获异常", e);
});
return thread;
}
}
4.3 线程池关闭不当
线程池的关闭方式有两种：shutdown()和shutdownNow()。如果关闭方式使用不当，可能会导致任务丢失或线程无法正常关闭。
4.3.1 shutdown () 与 shutdownNow () 的区别
- shutdown()：平缓关闭线程池。调用shutdown()方法后，线程池会拒绝接收新的任务，但会等待线程池中已提交的任务（包括正在执行的任务和在任务队列中等待的任务）全部执行完成后，再关闭线程池。
- shutdownNow()：强制关闭线程池。调用shutdownNow()方法后，线程池会立即尝试停止所有正在执行的任务，清空任务队列，并返回尚未执行的任务列表。需要注意的是，shutdownNow()方法并不能保证一定能停止正在执行的任务，它只是通过调用线程的interrupt()方法来中断线程，如果线程中的任务没有响应中断（如任务中没有检查中断状态，或者在执行不可中断的 IO 操作），那么任务可能会继续执行。
解决方案
在实际开发中，建议优先使用shutdown()方法关闭线程池，并配合awaitTermination()方法等待线程池关闭，确保所有任务都能执行完成。如果awaitTermination()方法超时，再考虑使用shutdownNow()方法强制关闭线程池。例如：
// 平缓关闭线程池
threadPool.shutdown();
try {
// 等待60秒，直到线程池中的所有任务都执行完成
if (!threadPool.awaitTermination(60, TimeUnit.SECONDS)) {
// 超时后，强制关闭线程池
ListexecutedTasks = threadPool.shutdownNow();
log.warn("线程池超时关闭，未执行的任务数量：" + unexecutedTasks.size());
// 等待强制关闭完成
if (!threadPool.awaitTermination(60, TimeUnit.SECONDS)) {
log.error("线程池无法正常关闭");
}
}
} catch (InterruptedException e) {
// 线程被中断，强制关闭线程池
threadPool.shutdownNow();
Thread.currentThread().interrupt();
log.error("线程池关闭过程被中断", e);
}
五、总结
线程池是 Java 并发编程中的核心技术，它通过资源复用、线程数量控制、任务队列缓冲等机制，有效提高了系统的并发处理能力和资源利用率。本文从线程池的必要性出发，详细讲解了 ThreadPoolExecutor 的核心参数、工作流程，以及线程池的使用示例和常见问题解决方案。
在实际开发中，我们需要根据业务场景合理配置线程池的参数，避免使用 Executors 工具类创建线程池带来的潜在风险。同时，要注意处理任务执行过程中的异常，选择合适的线程池关闭方式，确保线程池能够稳定、高效地运行。
掌握线程池技术不仅能够帮助我们写出更高效、更稳定的并发代码，也是深入理解 Java 并发编程模型的重要基础。希望本文能够对大家有所帮助，在今后的开发工作中，能够更好地运用线程池技术解决实际问题。
