JAVA 应用容器重启后线程数异常暴涨？ThreadFactory 的正确使用方式
大家好！今天我们来聊聊一个在 Java 应用中比较常见，但又常常被忽视的问题：应用容器重启后线程数异常暴涨。这个问题不仅会影响应用的性能，严重时甚至会导致系统崩溃。而问题的根源，很多时候都与 ThreadFactory 的不当使用有关。
一、问题背景：线程池与线程泄漏
在大型 Java 应用中，为了提高并发处理能力，我们通常会使用线程池。线程池可以复用线程，避免频繁创建和销毁线程带来的开销。Java 提供了 ExecutorService 接口及其实现类，如 ThreadPoolExecutor，方便我们管理线程池。
ExecutorService executor = Executors.newFixedThreadPool(10); // 创建一个固定大小为 10 的线程池
for (int i = 0; i < 100; i++) {
executor.submit(() -> {
// 执行一些任务
System.out.println("Task executed by thread: " + Thread.currentThread().getName());
});
}
executor.shutdown(); // 关闭线程池，不再接受新的任务
try {
executor.awaitTermination(10, TimeUnit.SECONDS); // 等待所有任务完成，最多等待 10 秒
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}这段代码创建了一个固定大小的线程池，提交了 100 个任务，然后关闭线程池。看似简单，但如果在实际应用中稍有不慎，就可能导致线程泄漏，最终表现为应用容器重启后线程数异常暴涨。
线程泄漏的根本原因是线程池中的线程没有被正确回收。这可能由以下几种原因导致：
- 任务执行时间过长或阻塞： 如果线程池中的任务执行时间过长或阻塞，会导致线程长时间占用，无法被其他任务复用。如果新的任务不断提交，线程池就会不断创建新的线程，最终达到线程池的最大线程数限制，甚至超出限制。
- 任务抛出未捕获的异常： 如果线程池中的任务抛出未捕获的异常，可能会导致线程异常终止，而线程池却没有及时发现并创建新的线程来替代它。长时间下来，线程池中的可用线程越来越少，最终导致线程泄漏。
- 错误的线程池配置： 线程池的配置参数，如核心线程数、最大线程数、空闲线程存活时间等，如果配置不当，也可能导致线程泄漏。例如，如果核心线程数和最大线程数设置相同，且空闲线程存活时间设置过长，那么线程池中的线程将永远不会被回收。
ThreadFactory使用不当： 这是我们今天要重点讨论的问题。ThreadFactory用于创建新的线程，如果ThreadFactory的实现不正确，可能会导致创建的线程无法被正确管理，从而导致线程泄漏。
二、ThreadFactory 的作用与重要性
ThreadFactory 是一个接口，只有一个方法：newThread(Runnable r)。它的作用是为线程池创建新的线程。为什么要使用 ThreadFactory 呢？
-
自定义线程属性：
ThreadFactory允许我们自定义线程的属性，例如线程名称、优先级、是否为守护线程等。这对于调试和监控线程池的运行状态非常有帮助。 -
统一线程管理： 通过
ThreadFactory，我们可以统一管理线程池中所有线程的创建过程，确保所有线程都具有相同的属性和行为。 -
更灵活的线程创建策略： 我们可以根据实际需求，实现不同的
ThreadFactory，以满足不同的线程创建策略。例如，我们可以创建一个ThreadFactory，用于创建守护线程，或者创建一个ThreadFactory，用于创建具有特定名称的线程。
然而，正是由于 ThreadFactory 的灵活性，如果使用不当，就会导致线程泄漏。
三、ThreadFactory 的错误使用方式及其危害
以下是一些常见的 ThreadFactory 错误使用方式：
-
忽略
Runnable参数： 有些开发者在实现ThreadFactory时，会忽略newThread(Runnable r)方法的Runnable参数，直接创建一个新的Thread对象，而不将Runnable传递给Thread对象。这会导致线程池无法正确执行任务。// 错误示例 class MyThreadFactory implements ThreadFactory { @Override public Thread newThread(Runnable r) { // 忽略 Runnable 参数 return new Thread(); } }这种写法会导致线程池无法执行提交的任务，因为
Thread对象没有绑定任何Runnable对象。 -
不设置线程名称： 如果不设置线程名称，线程池中的线程将使用默认的线程名称，例如 "pool-1-thread-1"，"pool-1-thread-2" 等。这会导致调试和监控线程池的运行状态变得非常困难。
// 错误示例 class MyThreadFactory implements ThreadFactory { @Override public Thread newThread(Runnable r) { return new Thread(r); // 没有设置线程名称 } } -
创建非守护线程： 默认情况下，
ThreadFactory创建的线程都是非守护线程。如果线程池中的所有线程都是非守护线程，那么即使主线程退出，应用也不会退出，因为非守护线程会阻止 JVM 退出。这可能会导致应用一直运行，占用系统资源。 -
创建线程后不进行任何处理： 某些情况下，可能会创建线程后没有启动，或者启动后没有进行任何处理，导致线程空转，浪费系统资源。
这些错误的使用方式都可能导致线程泄漏，最终表现为应用容器重启后线程数异常暴涨。
四、ThreadFactory 的正确使用方式
那么，如何正确使用 ThreadFactory 呢？
-
正确传递
Runnable参数： 在newThread(Runnable r)方法中，必须将Runnable参数传递给Thread对象，否则线程池将无法正确执行任务。// 正确示例 class MyThreadFactory implements ThreadFactory { private final String namePrefix; private final AtomicInteger threadNumber = new AtomicInteger(1); MyThreadFactory(String namePrefix) { this.namePrefix = namePrefix; } @Override public Thread newThread(Runnable r) { Thread thread = new Thread(r, namePrefix + "-" + threadNumber.getAndIncrement()); return thread; } } -
设置有意义的线程名称： 为线程设置有意义的名称，可以方便调试和监控线程池的运行状态。建议使用有意义的前缀，例如 "task-executor-thread-"。
// 正确示例 (基于上面的代码) class MyThreadFactory implements ThreadFactory { private final String namePrefix; private final AtomicInteger threadNumber = new AtomicInteger(1); MyThreadFactory(String namePrefix) { this.namePrefix = namePrefix; } @Override public Thread newThread(Runnable r) { Thread thread = new Thread(r, namePrefix + "-" + threadNumber.getAndIncrement()); return thread; } } -
根据需要创建守护线程： 如果线程池中的线程只需要在主线程运行时提供服务，那么可以将其设置为守护线程。守护线程不会阻止 JVM 退出。
// 正确示例 class MyThreadFactory implements ThreadFactory { private final String namePrefix; private final AtomicInteger threadNumber = new AtomicInteger(1); private final boolean daemon; MyThreadFactory(String namePrefix, boolean daemon) { this.namePrefix = namePrefix; this.daemon = daemon; } @Override public Thread newThread(Runnable r) { Thread thread = new Thread(r, namePrefix + "-" + threadNumber.getAndIncrement()); thread.setDaemon(daemon); return thread; } } -
在创建线程后进行必要的初始化操作： 例如，可以设置线程的
UncaughtExceptionHandler，用于处理未捕获的异常。// 正确示例 class MyThreadFactory implements ThreadFactory { private final String namePrefix; private final AtomicInteger threadNumber = new AtomicInteger(1); private final Thread.UncaughtExceptionHandler exceptionHandler; MyThreadFactory(String namePrefix, Thread.UncaughtExceptionHandler exceptionHandler) { this.namePrefix = namePrefix; this.exceptionHandler = exceptionHandler; } @Override public Thread newThread(Runnable r) { Thread thread = new Thread(r, namePrefix + "-" + threadNumber.getAndIncrement()); if (exceptionHandler != null) { thread.setUncaughtExceptionHandler(exceptionHandler); } return thread; } } -
使用
AtomicInteger保证线程编号的唯一性： 在为线程设置名称时，通常会使用一个递增的编号。为了保证线程编号的唯一性，建议使用AtomicInteger。// 正确示例 (基于上面的代码) private final AtomicInteger threadNumber = new AtomicInteger(1);
五、线程池的配置与监控
除了 ThreadFactory，线程池的配置和监控也很重要。
-
合理的线程池配置： 根据应用的实际需求，合理配置线程池的参数，如核心线程数、最大线程数、空闲线程存活时间等。
- 核心线程数（corePoolSize）： 线程池中始终保持的线程数量。即使线程处于空闲状态，也不会被回收。
- 最大线程数（maximumPoolSize）： 线程池中允许的最大线程数量。当任务队列已满，且线程池中的线程数量小于最大线程数时，线程池会创建新的线程来处理任务。
- 空闲线程存活时间（keepAliveTime）： 当线程池中的线程数量大于核心线程数时，多余的空闲线程在空闲时间超过该值时会被回收。
- 任务队列（workQueue）： 用于存储等待执行的任务。常见的任务队列有
ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue等。 - 拒绝策略（RejectedExecutionHandler）： 当任务队列已满，且线程池中的线程数量达到最大线程数时，线程池会使用拒绝策略来处理新的任务。常见的拒绝策略有
AbortPolicy、CallerRunsPolicy、DiscardPolicy、DiscardOldestPolicy等。
参数 描述 corePoolSize 核心线程数，线程池中始终保持的线程数量。 maximumPoolSize 最大线程数，线程池中允许的最大线程数量。 keepAliveTime 空闲线程存活时间，当线程池中的线程数量大于核心线程数时，多余的空闲线程在空闲时间超过该值时会被回收。 workQueue 任务队列，用于存储等待执行的任务。常见的任务队列有 ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue等。RejectedExecutionHandler 拒绝策略，当任务队列已满，且线程池中的线程数量达到最大线程数时，线程池会使用拒绝策略来处理新的任务。常见的拒绝策略有 AbortPolicy(抛出异常)、CallerRunsPolicy(由提交任务的线程执行)、DiscardPolicy(直接丢弃任务)、DiscardOldestPolicy(丢弃队列中最老的任务) 等。 -
线程池监控： 监控线程池的运行状态，例如活跃线程数、已完成任务数、排队任务数等。可以使用
ThreadPoolExecutor提供的方法，或者使用专业的监控工具，例如 JConsole、VisualVM 等。ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(10); // 获取线程池的运行状态 int activeCount = executor.getActiveCount(); // 活跃线程数 long completedTaskCount = executor.getCompletedTaskCount(); // 已完成任务数 long taskCount = executor.getTaskCount(); // 提交的任务总数 int queueSize = executor.getQueue().size(); // 队列中等待的任务数
六、使用 CompletableFuture 简化异步编程
CompletableFuture 是 Java 8 引入的一个强大的异步编程工具。它可以简化异步编程的复杂性，提高代码的可读性和可维护性。
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
// 执行一些耗时操作
return "Hello, World!";
});
future.thenAccept(result -> {
// 处理结果
System.out.println("Result: " + result);
});
future.exceptionally(ex -> {
// 处理异常
System.err.println("Error: " + ex.getMessage());
return null;
});CompletableFuture 可以链式调用多个操作，例如 thenApply、thenAccept、thenCompose 等，方便构建复杂的异步流程。
使用 CompletableFuture 可以避免手动创建线程池，减少线程管理的负担。但是，在使用 CompletableFuture 时，仍然需要注意线程安全问题，避免出现并发错误。
七、案例分析：Tomcat 线程池配置不当导致线程暴涨
曾经遇到一个案例，一个 Java Web 应用部署在 Tomcat 容器中，应用使用了线程池来处理一些异步任务。由于对 Tomcat 线程池的配置不熟悉，将 maxThreads 设置得过大，而 acceptCount 设置得过小。当并发请求量较大时，Tomcat 会创建大量的线程，最终导致线程数超过系统限制，应用崩溃。
<!-- Tomcat 的 server.xml 文件 -->
<Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443"
maxThreads="1000" <!-- 设置过大 -->
acceptCount="100" <!-- 设置过小 -->
/>在这个案例中，应该根据服务器的硬件资源和应用的实际需求，合理配置 maxThreads 和 acceptCount。同时，应该监控 Tomcat 的线程池状态，及时发现并解决问题。
八、代码示例：一个完整的线程池使用示例
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
public class ThreadPoolExample {
public static void main(String[] args) throws InterruptedException {
// 创建一个自定义的 ThreadFactory
ThreadFactory threadFactory = new MyThreadFactory("task-executor-thread");
// 创建一个具有合理配置的线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(
5, // 核心线程数
10, // 最大线程数
60L, // 空闲线程存活时间
TimeUnit.SECONDS, // 时间单位
new LinkedBlockingQueue<>(100), // 任务队列
threadFactory, // ThreadFactory
new ThreadPoolExecutor.AbortPolicy() // 拒绝策略
);
// 提交任务
for (int i = 0; i < 20; i++) {
final int taskId = i;
executor.submit(() -> {
try {
// 模拟耗时操作
Thread.sleep(1000);
System.out.println("Task " + taskId + " executed by thread: " + Thread.currentThread().getName());
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
}
// 关闭线程池
executor.shutdown();
executor.awaitTermination(10, TimeUnit.SECONDS);
System.out.println("All tasks completed.");
}
// 自定义的 ThreadFactory
static class MyThreadFactory implements ThreadFactory {
private final String namePrefix;
private final AtomicInteger threadNumber = new AtomicInteger(1);
MyThreadFactory(String namePrefix) {
this.namePrefix = namePrefix;
}
@Override
public Thread newThread(Runnable r) {
Thread thread = new Thread(r, namePrefix + "-" + threadNumber.getAndIncrement());
// 可选：设置 UncaughtExceptionHandler
thread.setUncaughtExceptionHandler((t, e) -> {
System.err.println("Uncaught exception in thread: " + t.getName() + ", " + e.getMessage());
});
return thread;
}
}
}这个示例展示了如何创建一个自定义的 ThreadFactory，并将其用于创建一个具有合理配置的线程池。同时，示例还展示了如何设置线程的 UncaughtExceptionHandler，用于处理未捕获的异常。
九、监控与诊断工具
在解决线程问题时，一些监控和诊断工具可以提供很大的帮助：
- JConsole: JDK 自带的图形化监控工具，可以查看线程信息，堆内存使用情况，以及执行 JMX 操作。
- VisualVM: 另一个 JDK 自带的图形化监控工具，功能比 JConsole 更强大，可以分析 CPU 使用情况，内存泄漏，以及线程死锁。
- Arthas: 阿里巴巴开源的 Java 诊断工具，可以在不重启应用的情况下，动态地查看和修改应用的运行状态。
这些工具可以帮助我们快速定位线程问题，并找到解决方案。
避免线程泄漏，合理使用线程池
通过今天的分享，希望大家能够更加深入地理解 ThreadFactory 的作用和重要性，避免在使用 ThreadFactory 时出现错误，从而避免线程泄漏。同时，希望大家能够合理配置线程池，并使用监控工具监控线程池的运行状态，及时发现并解决问题。记住，合理使用线程池是提高 Java 应用性能的关键。