java 线程池监控的核心做法是继承 threadpoolexecutor 并重写 afterexecute 方法,在任务执行结束后自动捕获异常并记录日志。通过这种方式,可以在不侵入业务代码的前提下,实时获取线程池的运行状态和错误信息。

如何自定义线程池以捕获未处理异常?
直接回答:通过重写 afterExecute 方法,可以拦截所有任务的执行结果,包括抛出的异常。这是实现线程池监控最基础且有效的手段。

import java.util.concurrent.*;
public class MonitoredThreadPool extends ThreadPoolExecutor {
public MonitoredThreadPool(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue<runnable> workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
@Override
protected void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
if (t == null && r instanceof Future>) {
try {
Future> future = (Future>) r;
if (future.isDone()) {
t = future.getException();
}
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
} catch (ExecutionException ee) {
t = ee.getCause();
}
}
if (t != null) {
System.out.println("Task failed with exception: " + t.getMessage());
} else {
System.out.println("Task executed successfully.");
}
}
public static void main(String[] args) {
ExecutorService executor = new MonitoredThreadPool(1, 1, 0L, TimeUnit.SECONDS, new LinkedBlockingQueue());
executor.execute(() -> { throw new RuntimeException("Test Error"); });
executor.shutdown();
}
}</runnable>
上述代码定义了一个名为 MonitoredThreadPool 的类,它继承了 ThreadPoolExecutor。在 main 方法中,我们创建了一个单线程池,并提交了一个会抛出 RuntimeException 的任务。运行该程序后,控制台将输出 “Task failed with exception: Test Error”。如果任务正常执行,则输出 “Task executed successfully.”。这种机制确保了即使任务在内部吞掉了异常,只要是通过 execute 提交的任务,其异常都能被 afterExecute 捕获(对于 submit 提交的任务,需通过 Future.get() 获取,但 afterExecute 也能通过 Future 接口间接获取)。
如何实时监控线程池的队列与活跃线程数?
直接回答:可以通过定期调用 getQueue().size()、getActiveCount() 和 getPoolSize() 方法来获取线程池的当前状态。将这些数据上报到监控系统(如 Prometheus 或 JMX),即可实现实时监控。
使用Atmosphere构建通过WebSocket、SSE、gRPC、WebTransport、MCP、A2A和AG-UI流传输的JVM代理网关,并带有治理钩子。

import java.util.concurrent.*;
public class PoolStatusMonitor {
private final ThreadPoolExecutor executor;
public PoolStatusMonitor(ThreadPoolExecutor executor) {
this.executor = executor;
}
public void printStatus() {
System.out.println("Pool Size: " + executor.getPoolSize());
System.out.println("Active Count: " + executor.getActiveCount());
System.out.println("Queue Size: " + executor.getQueue().size());
System.out.println("Completed Task Count: " + executor.getCompletedTaskCount());
}
public static void main(String[] args) throws InterruptedException {
ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue(10));
PoolStatusMonitor monitor = new PoolStatusMonitor(executor);
// 提交多个任务以填充队列
for (int i = 0; i {
try { Thread.sleep(1000); } catch (InterruptedException e) {}
});
}
// 等待一段时间让任务执行
Thread.sleep(500);
monitor.printStatus();
executor.shutdown();
}
}
这段代码展示了如何创建一个 PoolStatusMonitor 类来封装对 ThreadPoolExecutor 状态的查询。在 main 方法中,我们创建了一个核心线程数为 2、最大线程数为 4、队列容量为 10 的线程池。提交了 15 个任务,每个任务休眠 1 秒。在提交后立即打印状态,此时可以看到队列中有任务堆积,活跃线程数达到最大值。通过定期调用 printStatus 方法,开发者可以观察线程池的动态变化,从而判断是否存在资源瓶颈或任务积压问题。
当线程池队列满时,拒绝策略如何影响监控?
直接回答:当线程池队列满且线程数达到最大值时,新提交的任务会被拒绝。不同的 RejectedExecutionHandler 策略会导致不同的行为,例如 AbortPolicy 会抛出异常,而 CallerRunsPolicy 会在调用者线程中执行任务。监控时需要针对这些策略进行相应的异常捕获或逻辑处理。
import java.util.concurrent.*;
public class RejectionMonitor {
public static void main(String[] args) {
ThreadPoolExecutor executor = new ThreadPoolExecutor(
1, 1, 0L, TimeUnit.SECONDS,
new LinkedBlockingQueue(1),
new ThreadPoolExecutor.CallerRunsPolicy()
);
// 提交两个任务,第一个由工作线程执行,第二个因队列满且线程满,由调用者线程执行
executor.execute(() -> System.out.println("Task 1 by thread: " + Thread.currentThread().getName()));
executor.execute(() -> System.out.println("Task 2 by thread: " + Thread.currentThread().getName()));
executor.shutdown();
}
}
在上述代码中,我们使用了一个核心线程数为 1、最大线程数为 1、队列容量为 1 的线程池,并设置了 CallerRunsPolicy 作为拒绝策略。首先提交一个任务,该任务由工作线程执行。接着提交第二个任务,由于队列已满且线程数已达上限,根据 CallerRunsPolicy,第二个任务将在主线程(即调用 execute 的线程)中执行。这会导致主线程阻塞,直到任务完成。在监控场景中,如果发现任务执行时间突然变长,或者主线程出现阻塞,可能需要检查是否触发了拒绝策略,并考虑调整线程池参数或更换拒绝策略(如 DiscardPolicy 或自定义策略)。
Java免费学习笔记:立即使用
解锁 Java 大师之旅:从入门到精通的终极指南










