执行器线程异常结束后未耗尽可用线程？线程池行为及异常传递问询

Hey there! Let's unpack your two thread pool questions—this is a super common point of confusion, so great call asking about it.

The short answer: Thread pools are built to be resilient. When a worker thread dies from an uncaught exception, the pool will automatically replace it (under normal operating conditions) to maintain its intended thread count.

Here's the breakdown by thread type in a typical ThreadPoolExecutor:

• Core threads: If a core thread (part of the corePoolSize set) crashes due to an exception, the pool will immediately spin up a new core thread to take its place—unless the pool is in the process of shutting down. This ensures the pool always has its base number of threads ready to handle tasks.
• Non-core threads: These are threads created beyond corePoolSize when the task queue is full. If one of these dies from an exception, the pool won't replace it right away. But if there are still pending tasks in the queue and the current thread count is below maximumPoolSize, the pool will create a new non-core thread to pick up the slack.

To see this in action, take this quick example:

ExecutorService executor = Executors.newFixedThreadPool(2);
// Submit a task that crashes the thread
executor.submit(() -> {
    throw new RuntimeException("Oops, this thread crashed!");
});
// Submit a second task— it will still run because the pool replaced the dead thread
executor.submit(() -> {
    System.out.println("This task runs perfectly fine!");
});
executor.shutdown();

After the first task crashes its thread, the pool creates a new one, so the second task has a thread to run on. No exhaustion here!

Let's split this into two parts: how the pool behaves, and how exceptions reach your main thread.

Thread Pool Behavior #

First off: A single task's exception won't take down the entire thread pool. Here's what happens step by step:

1. The worker thread executing the task throws an uncaught exception and terminates.
2. As we covered in Question 1, the pool will replace the thread if needed (core threads get replaced automatically; non-core threads get replaced only if there's work left and we're under maximumPoolSize).
3. The pool continues processing subsequent tasks like nothing happened—this is why you saw it handling follow-up requests without issues.

The key difference in behavior comes down to how you submit the task:

• If you use execute(): The exception is handled by the thread's UncaughtExceptionHandler (the default one prints the stack trace to System.err).
• If you use submit(): The exception is silently wrapped up in the Future object returned by submit()—it won't show up until you call future.get().

Passing Exceptions to the Main Thread #

Again, this depends on your submission method:

1. Using execute():
   By default, uncaught exceptions go to the console. To customize this, you can set a custom UncaughtExceptionHandler when creating threads for the pool, or override the pool's afterExecute method to handle exceptions directly. Example:

   ExecutorService executor = Executors.newSingleThreadExecutor(r -> {
       Thread t = new Thread(r);
       t.setUncaughtExceptionHandler((thread, throwable) -> {
           System.out.println("Custom handler caught: " + throwable.getMessage());
       });
       return t;
   });
   executor.execute(() -> {
       throw new RuntimeException("Execute task failed!");
   });
   executor.shutdown();
   

2. Using submit():
   The exception is stored in the Future. When you call future.get(), it will throw an ExecutionException, and you can get the original exception via e.getCause(). Example:

   ExecutorService executor = Executors.newSingleThreadExecutor();
   Future<?> future = executor.submit(() -> {
       throw new RuntimeException("Submit task failed!");
   });
   try {
       future.get();
   } catch (ExecutionException e) {
       System.out.println("Caught exception from submit: " + e.getCause().getMessage());
   } catch (InterruptedException e) {
       Thread.currentThread().interrupt();
   }
   executor.shutdown();
   

内容的提问来源于stack exchange，提问作者Jaraws