ExecutionException Java 8

With the advent of multithreading and asynchronous programming, Java provides a potent method for task execution in parallel called the ExecutorService. However, you could encounter an ExecutionException when managing many threads and addressing errors that arise during task execution. In this section, we will examine the specifics of Java 8 ExecutionException, including what it is, when it happens, and how to successfully manage it with complete code samples.

What is ExecutionException?

When using Java's ExecutorService, the ExecutionException exception may be raised. It is a checked exception that denotes an issue with an ExecutorService's ability to carry out a job that was given to it. This exception often encapsulates another exception that happened while the job was being executed, enabling you to handle it properly.

When Does ExecutionException Occur?

ExecutionException is often issued when a job sent to an ExecutorService is being executed and an error occurs. This internal exception may be any type that was thrown within the task's code, including RuntimeException, CheckedException, and others.

ExecutionException frequently happens in the following circumstances:

Unchecked Exceptions: If a task throws an unchecked exception during execution, such as a NullPointerException.
IOException is an example of a checked exception that the job may raise if we have not expressly caught or managed it.
Nested Exceptions: An ExecutionException is thrown when a task itself catches an exception but re-throws it.

The Anatomy of ExecutionException

The composite exception known as ExecutionException encapsulates the root cause exception. This "inner exception," often known as the underlying cause, can occasionally be nested inside multiple layers of exceptions. Understanding that the innermost exception contains the most pertinent information is essential when addressing execution exceptions. Therefore, it is crucial to navigate the exception hierarchy in order to reach the deepest cause.

We may get the innermost exception by following these steps:

Throwable rootCause = e;
while (rootCause.getCause() != null) {
    rootCause = rootCause.getCause();
}

Thread Safety

Make sure your tasks are thread-safe before utilising an ExecutorService because they could be carried out concurrently by several threads. Failure to maintain thread safety might result in irrational behaviour and competitive situations.

Graceful termination

To save up system resources, always shut down your ExecutorService after using it. Resource leaks might result from neglecting to do so. To start an orderly shutdown, call executor.shutdown() and then execute.awaitTermination() is used to watch for job completion.

Here are some code samples to help us examine these topics.

Example 1: Unchecked Exception

import java.util.concurrent.*;
public class ExecutionExceptionExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(1);
        Future<?> future = executor.submit(() -> {
            throw new NullPointerException("Unchecked Exception");
        });
        try {
            future.get();
        } catch (InterruptedException | ExecutionException e) {
            if (e.getCause() instanceof NullPointerException) {
                System.out.println("Caught an Unchecked Exception: " + e.getCause().getMessage());
            }
        }
        executor.shutdown();
    }
}

Output:

Caught an Unchecked Exception: Unchecked Exception

Explanation

In this example, we submit a task that throws a NullPointerException. The ExecutionException wraps this exception, allowing us to catch and handle it appropriately.

Example 2: Checked Exception

ExecutionExceptionExample.java

import java.io.IOException;
import java.util.concurrent.*;
public class ExecutionExceptionExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(1);
        Future<?> future = executor.submit(() -> {
            try {
                throw new IOException("Checked Exception");
            } catch (IOException e) {
                System.out.println("Caught a Checked Exception: " + e.getMessage());
                throw new RuntimeException(e);
            }
        });
        try {
            future.get();
        } catch (InterruptedException | ExecutionException e) {
            if (e.getCause() instanceof RuntimeException) {
                System.out.println("Caught a Runtime Exception: " + e.getCause().getMessage());
            }
        }
        executor.shutdown();
    }
}

Output:

Caught a Checked Exception: Checked Exception
Caught a Runtime Exception: java.io.IOException: Checked Exception

Explanation

In this example, the task throws a checked IOException, which is caught and rethrown as a RuntimeException. The ExecutionException wraps the rethrown exception, allowing us to handle the original checked exception.

Handling ExecutionException

To handle ExecutionException effectively, we can follow these steps:

Use a try-catch block when calling future.get() to catch the ExecutionException.
Access the wrapped exception using e.getCause().
Determine the type of exception wrapped in the ExecutionException to take appropriate action.
Implement the necessary error-handling logic based on the type of the inner exception.

By following these steps, we can gracefully manage exceptions that occur during task execution.

Conclusion

ExecutionException is a valuable tool for dealing with exceptions that may arise when working with concurrent tasks in Java using the ExecutorService. Understanding how to handle this exception allows you to create robust and error-tolerant multithreaded applications. By catching and analysing the wrapped exception, we can respond to errors in a structured and meaningful way, ensuring the reliability of applications.

Next TopicGeneric Object in Java

← prev next →