Imagine running a team project: if one member fails silently, the project suffers without anyone knowing why. Similarly, in Java multithreading, exceptions in threads and executor tasks often vanish unless explicitly handled. This can lead to silent failures, hard-to-debug issues, or system instability.

This tutorial explains how to deal with exceptions in Executors, Futures, and Threads, with examples, best practices, and modern Java features.

Purpose of Java Exception Handling

Prevent silent task failures.
Propagate exceptions to calling threads safely.
Provide actionable logs and diagnostics.

Real-world analogy: Exception handling in executors and threads is like project tracking software—if a member fails to deliver, the system notifies the manager immediately.

Errors vs Exceptions in Java

At the root of Java’s throwable system is Throwable:

Error: Irrecoverable problems like OutOfMemoryError.
Exception: Recoverable issues like IOException and SQLException.

Exception Hierarchy

Throwable
 ├── Error (unrecoverable)
 │    └── OutOfMemoryError, StackOverflowError
 └── Exception
      ├── Checked (must be declared or handled)
      │    └── IOException, SQLException
      └── Unchecked (RuntimeException)
           └── NullPointerException, ArithmeticException

Exceptions in Threads

public class Worker extends Thread {
    @Override
    public void run() {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("Handled in thread: " + e.getMessage());
        }
    }
}

If uncaught, exceptions terminate only that thread.
Other threads continue unaffected.

Global Exception Handling in Threads

Thread.setDefaultUncaughtExceptionHandler((thread, e) -> {
    System.out.println("Uncaught exception in " + thread.getName() + ": " + e);
});

Catches exceptions missed in thread code.
Useful for logging and monitoring.

Exceptions in ExecutorService

When using thread pools, tasks return Future.

ExecutorService executor = Executors.newFixedThreadPool(2);

Future<Integer> future = executor.submit(() -> 10 / 0);

try {
    future.get(); // throws ExecutionException
} catch (ExecutionException e) {
    System.out.println("Task failed with: " + e.getCause());
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

Exceptions are wrapped in ExecutionException.
Always inspect e.getCause().

Exceptions in CompletableFuture

CompletableFuture<Integer> cf = CompletableFuture.supplyAsync(() -> {
    return 10 / 0;
}).exceptionally(ex -> {
    System.out.println("Handled: " + ex);
    return 0;
});

System.out.println(cf.join());

exceptionally() recovers with fallback values.
handle() allows handling both success and failure.

CompletableFuture<Integer> cf2 = CompletableFuture.supplyAsync(() -> {
    throw new IllegalArgumentException("Invalid input");
}).handle((result, ex) -> {
    if (ex != null) {
        System.out.println("Error: " + ex.getMessage());
        return -1;
    }
    return result;
});

Best Practices

Always handle exceptions in thread run() methods.
For ExecutorService, wrap logic in try-catch and check Future.get().
Use CompletableFuture for async pipelines with clean error recovery.
Log exceptions with stack traces.
Use uncaught exception handlers for global coverage.
In modern Java, prefer structured concurrency (Java 21).

Anti-Patterns

Ignoring exceptions in worker threads.
Swallowing exceptions silently.
Overusing System.out.println instead of logging frameworks.
Forgetting to shut down executors.

Real-World Scenarios

File I/O

Future<String> f = executor.submit(() -> new String(Files.readAllBytes(Path.of("file.txt"))));

JDBC

Future<ResultSet> rs = executor.submit(() -> stmt.executeQuery("SELECT * FROM users"));

REST APIs with CompletableFuture

CompletableFuture.supplyAsync(() -> restTemplate.getForObject(url, String.class))
    .exceptionally(ex -> "Fallback response");

Multithreading with Spring Boot

@Async
public CompletableFuture<User> fetchUser(int id) {
    try {
        return CompletableFuture.completedFuture(findUser(id));
    } catch (Exception e) {
        return CompletableFuture.failedFuture(e);
    }
}

📌 What's New in Java Exception Handling

Java 7+: Multi-catch, try-with-resources.
Java 8: CompletableFuture with exception handling.
Java 9+: Stack-Walking API for efficient error analysis.
Java 14+: Helpful NullPointerException messages.
Java 21: Structured concurrency improves error propagation.

FAQ: Expert-Level Questions

Q1. Why don’t exceptions in threads propagate to main thread?
Each thread has its own call stack—exceptions don’t cross boundaries.

Q2. How do I capture exceptions in ExecutorService?
Call Future.get() and check ExecutionException.

Q3. How is CompletableFuture different from Future?
It supports async pipelines and built-in exception handling.

Q4. Can I set a default exception handler for all threads?
Yes, with Thread.setDefaultUncaughtExceptionHandler.

Q5. Should I log exceptions or rethrow them?
Depends—log for diagnostics, rethrow for higher-level handling.

Q6. Is exception handling costly in threads?
The throw-catch mechanism is expensive; avoid using it for flow control.

Q7. Can I retry tasks automatically?
Yes, implement retry logic in thread pools or CompletableFuture.

Q8. What about suppressed exceptions?
Check Throwable.getSuppressed() when multiple failures occur.

Q9. Should I use checked or unchecked exceptions in threads?
Unchecked simplifies async signatures—prefer them unless recovery is required.

Q10. How does structured concurrency help?
Introduced in Java 21, it manages sibling tasks and propagates exceptions predictably.

Conclusion and Key Takeaways

Exceptions in threads don’t propagate automatically.
Executors wrap them in ExecutionException.
Futures and CompletableFuture provide structured recovery.
Always log and handle exceptions explicitly.
Structured concurrency (Java 21) modernizes exception handling.

By mastering these techniques, you’ll build reliable, maintainable, and production-ready multithreaded Java applications.

Dealing with Exceptions in Executors, Futures, and Threads in Java