How to solve java.util.concurrent.RejectedExecutionException : Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task rejected from: java.util.concurrent.ThreadPoolExecutor@1b6d3586[Shutting down, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 5]

What is the RejectedExecutionException?
Causes of RejectedExecutionException
How to Handle RejectedExecutionException
Best Practices to Avoid RejectedExecutionException
Example Code Demonstration
15 Frequently Asked Questions (FAQs) About RejectedExecutionException

Understanding the Java Error: java.util.concurrent.RejectedExecutionException – Submitting Tasks to a Shutdown Executor

In the world of Java programming, exceptions are an inevitable part of development, providing developers with insights into what went wrong during execution. One such exception is the RejectedExecutionException, which can arise when you attempt to submit a task to an executor that has already been shut down. This exception may seem a bit confusing at first, especially for beginner Java developers, but understanding its cause and how to resolve it is essential for writing robust, production-ready code.

In this comprehensive guide, we’ll dive deep into the RejectedExecutionException error, explain why it occurs, how to handle it, and what preventative measures you can take to avoid it in your applications.

What is the RejectedExecutionException?

In Java, executors are used to manage and run threads in a concurrent programming environment. Executors are often implemented by the ExecutorService interface, which provides methods for managing and controlling thread execution in a thread pool. However, there is a limit to the number of tasks an executor can handle. When this limit is exceeded, or the executor is explicitly shut down, any subsequent attempts to submit tasks will result in a RejectedExecutionException.

The RejectedExecutionException specifically occurs when a task is submitted to an executor that has been shut down using methods like shutdown() or shutdownNow(). In simpler terms, if you attempt to submit a new task to an executor that has already been marked for termination, Java will throw this exception to indicate that the task cannot be processed.

Causes of RejectedExecutionException

There are several key reasons why this exception might occur in your Java program:

Executor Shutdown: The primary cause of the RejectedExecutionException is that the executor has been shut down, either intentionally or accidentally. When an executor is shut down, it can no longer accept new tasks, and attempts to submit tasks will result in this error.
Task Submission After Executor Shutdown: If your code tries to submit tasks to an executor after calling its shutdown() or shutdownNow() methods, the executor will reject any new tasks by throwing a RejectedExecutionException. These methods signal that no more tasks will be accepted, and the executor will complete any pending tasks before stopping.
Exceeding the Task Queue Capacity: If the executor is configured with a bounded queue (i.e., the task queue has a limited size), and that queue is full, any additional tasks submitted will be rejected. The executor may either reject the task immediately, or throw the RejectedExecutionException depending on its configuration.
Executor Not Properly Initialized: A poorly initialized executor might lead to unexpected behaviors, including rejecting tasks due to improper configuration or other internal issues.

How to Handle RejectedExecutionException

Handling the RejectedExecutionException effectively is crucial to building resilient Java applications. Here are some strategies to avoid and handle this exception in your code:

Graceful Shutdown of Executors: One of the most important practices when working with executors is to ensure that you shut them down gracefully. Always call the shutdown() method once you no longer need to submit tasks. This allows the executor to complete all currently executing tasks before shutting down. If you attempt to submit tasks after calling shutdown(), it will throw a RejectedExecutionException.
```
ExecutorService executor = Executors.newFixedThreadPool(10);
executor.submit(() -> System.out.println("Task executed"));

// Shut down the executor after completing all tasks
executor.shutdown();
```
Check If Executor is Shutdown: Before submitting tasks to an executor, always check whether it has already been shut down. You can use the isShutdown() and isTerminated() methods to determine the state of the executor.
```
if (!executor.isShutdown()) {
    executor.submit(() -> System.out.println("Task executed"));
}
```
Rejection Handlers (Custom Rejection Policies): If you're using an ExecutorService, particularly a ThreadPoolExecutor, you can specify a custom rejection handler. This handler allows you to control what happens when a task is rejected due to an executor’s shutdown or a full task queue.
```
ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 10, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(10), new ThreadPoolExecutor.AbortPolicy());
executor.submit(() -> System.out.println("Task executed"));
```
Ensure Proper Shutdown Procedure: Always ensure that your application has a clear shutdown procedure. This helps avoid situations where tasks are still submitted to an executor after it has been shut down. This can be especially helpful when you are working with large-scale applications where multiple threads or components are interacting.
Use a ThreadPoolExecutor with a Custom Rejection Policy: A ThreadPoolExecutor allows you to define your own rejection policy. You can set it to ignore, log, or retry rejected tasks. For instance, you can use the DiscardPolicy, which discards tasks that cannot be executed, or the CallerRunsPolicy, which runs the task on the caller's thread if the executor is overloaded.
```
ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(100), new ThreadPoolExecutor.CallerRunsPolicy());
```

Best Practices to Avoid RejectedExecutionException

While handling exceptions is a critical part of Java development, it's always better to prevent them in the first place. Here are some best practices that can help you avoid encountering RejectedExecutionException in your applications:

Avoid Submitting Tasks After Executor Shutdown: The best way to prevent this error is to ensure that you don't submit tasks after the executor has been shut down. This can be accomplished by managing the lifecycle of the executor properly.
Properly Manage Executor Lifecycle: Always close or shutdown your executors properly. Failing to do so may result in unfinished tasks or unexpected behaviors when the executor is no longer available.
Use a Timeout for Task Submissions: Implement a timeout for task submissions to avoid blocking threads indefinitely if the task queue is full or the executor is unavailable.
Handle Task Rejection Gracefully: Implement a rejection policy that ensures rejected tasks don’t go unnoticed. You can log them, resubmit them after a delay, or handle them in a manner that fits the needs of your application.
Scale Executors Based on Demand: Dynamically adjust the number of threads in your executor based on workload. If the executor is frequently rejecting tasks, it may be necessary to increase its capacity or introduce additional executors.

Example Code Demonstration

Let’s take a look at a complete example of how to handle the RejectedExecutionException:

import java.util.concurrent.*;

public class ExecutorExample {

    public static void main(String[] args) {
        ExecutorService executor = new ThreadPoolExecutor(
                2, 4, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(2));

        try {
            for (int i = 0; i < 10; i++) {
                final int taskId = i;
                executor.submit(() -> {
                    try {
                        System.out.println("Task " + taskId + " is executing.");
                        Thread.sleep(1000); // Simulate task
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                });
            }
        } catch (RejectedExecutionException e) {
            System.out.println("Task rejected: " + e.getMessage());
        } finally {
            executor.shutdown();
        }
    }
}

In the above example, tasks are submitted to an executor with a bounded queue of size 2. Once the queue is full, new tasks will be rejected, and a RejectedExecutionException will be thrown, which we handle gracefully.

15 Frequently Asked Questions (FAQs) About RejectedExecutionException

What is a RejectedExecutionException? It occurs when a task is submitted to an executor that has already been shut down.
How do I avoid RejectedExecutionException? Ensure you don't submit tasks after calling shutdown() on the executor, and always check if the executor is in a shutdown state.
Can I submit tasks to a shutdown executor? No, once the executor is shut down, it cannot accept new tasks.
What methods can I use to check if an executor is shutdown? Use the isShutdown() and isTerminated() methods.
How can I configure a custom rejection policy? You can use the ThreadPoolExecutor class and specify a rejection handler, such as AbortPolicy, CallerRunsPolicy, or DiscardPolicy.
What happens if an executor is not shut down properly? If you fail to shut down the executor properly, it can lead to unfinished tasks and potential resource leaks.
Can I handle a RejectedExecutionException? Yes, you can catch the exception and decide how to handle rejected tasks, like logging or retrying.
What is the default rejection policy in Java? The default policy is AbortPolicy, which throws a RejectedExecutionException.
How can I scale the number of threads in an executor? Use the ThreadPoolExecutor to dynamically adjust the core and maximum pool sizes based on workload.
What is the difference between shutdown and shutdownNow? shutdown() initiates an orderly shutdown, while shutdownNow() attempts to stop all actively executing tasks immediately.
Can I resubmit rejected tasks? Yes, you can capture the rejected task and resubmit it using another executor.
What is the best way to shut down an executor? Always use shutdown() to allow pending tasks to finish, or shutdownNow() to stop them immediately.
Is the RejectedExecutionException a checked or unchecked exception? It is an unchecked exception that extends RuntimeException.
Can I avoid the executor rejecting tasks? Increase the executor’s queue size or the number of threads to accommodate more tasks.
When should I use shutdownNow() instead of shutdown()? Use shutdownNow() when you need to halt the executor immediately and discard pending tasks. Otherwise, prefer shutdown() for a clean shutdown.

Conclusion

The RejectedExecutionException in Java is an important exception to understand, as it occurs when trying to submit tasks to an executor that is no longer accepting new tasks due to a shutdown. By following best practices for managing the lifecycle of executors, handling exceptions gracefully, and ensuring proper configuration, you can avoid and manage this error effectively. Proper handling and prevention of such exceptions will help you write efficient, reliable, and production-ready Java applications.

Search This Blog