Handling exceptions from Java ExecutorService tasks

java

exception-handling

executor-service

threadpool

byNikita Barsukov·Dec 26, 2024

Efficient exception handling is vital in Java's ExecutorService tasks. Capture the Future results via Callable tasks. future.get() sifts through any issues, courtesy of the ExecutionException it throws for faults within tasks. Below is a quickfire way:

ExecutorService service = Executors.newFixedThreadPool(10); // Pool party!
Future<?> future = service.submit(() -> {
    if (someCondition) throw new Exception("Exploding task!"); // Just like my college assignments
    return "Task done, boss!";
});
try {
    System.out.println(future.get()); // Let's see what mess you made...
} catch (ExecutionException e) {
    Throwable cause = e.getCause(); // The true culprit
} catch (InterruptedException e) {
    Thread.currentThread().interrupt(); // Restoring the status quo
}
service.shutdown(); // Lights out!

This sorted, you can flex your ability to capture those pesky exceptions from your tasks and handle interrupts, keeping the main thread in the loop.

Diverse palette of exception handlers

We're not just about catching exceptions here. It's also essential to crack open the flow of task execution and arm yourself with the right patterns to build robust and resilient systems.

Reflecting on Runnable and Callable

Let's clarify: Runnable tasks can't throw checked exceptions or return a result. If you yearn to handle specific exceptions or return a value, go with Callable. Instead, with Runnable, capture exceptions in the task body, and wave the exception flag for the external world or a callback system.

ThreadPoolExecutor: The saviour ribbon

I'm sure you've heard of afterExecute in ThreadPoolExecutor. It's perfect if you need more control over task completion, such as when a future finishes abnormally. Here's a sneak peek into it:

protected void afterExecute(Runnable r, Throwable t) {
    super.afterExecute(r, t);
    if (t == null && r instanceof Future<?>) {
        try {
            Object result = ((Future<?>) r).get();
        } catch (CancellationException ce) {
            t = ce;
        } catch (ExecutionException ee) {
            t = ee.getCause(); // Loading... Error 404: Execution not found
        } catch (InterruptedException ie) {
            Thread.currentThread().interrupt(); // Don't shoot the messenger!
        }
    }
    if (t != null) {
        // Time to face your bulging backlog of Throwable exceptions
    }
}

Butterfingered exceptions

You know that old saying about distinguishing between fatal and recoverable exceptions? (Well, there isn't one, but let's pretend.) If a task throws a recoverable exception, it might be smart to resubmit the task to the ExecutorService:

try {
    future.get();
} catch (ExecutionException e) {
    if (isRecoverable(e.getCause())) {
        service.submit(task); // Oops! Let's try this again
    }
}

Global exception babysitters

Uncaught exceptions are not orphans! Define a global uncaught exception handler with Thread.setDefaultUncaughtExceptionHandler and set up a global strategy for handling them.

Advanced patterns and pratfalls

You've made it this far! If you think you've seen it all, we're cracking open the enigma code of the advanced patterns in the world of Java exceptions.

Charming Decorators

Embrace decorators or wrappers around Runnable or Callable, and add additional behavior like logging, retry mechanisms, or custom exception handling, keeping your concerns clean.

The future ain't what it used to be!

Future and ThreadPoolExecutor do have some peculiarities:

isDone() can't predict your future! It only tells you the job's done, even if it ended with a mishap or abrupt cancellation.
CompletableFuture got a nifty pair of methods: handle and exceptionally — your easy answers to streamlined exception handling.