Mastering Java ThreadPool Rejection Policies: Which One Fits Your Needs?

Java thread pool rejection policies are a core part of concurrency control and are frequently examined in large‑scale system interviews. Below is a detailed explanation of the four standard policies, their source code, suitable scenarios, strengths, and limitations.

1. AbortPolicy (default)

The default policy throws a RejectedExecutionException when the pool is saturated, preventing further task execution.

public static class AbortPolicy implements RejectedExecutionHandler {
    public AbortPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() +
                                             " rejected from " +
                                             e.toString());
    }
}

Use case: When immediate feedback on task rejection is required and the caller can handle the exception.

Pros: Clearly signals rejection, avoiding silent task loss.

Cons: Caller must catch the exception; otherwise stability may be affected.

2. CallerRunsPolicy

This policy runs the rejected task in the thread that invoked execute, slowing down the submission rate.

public static class CallerRunsPolicy implements RejectedExecutionHandler {
    public CallerRunsPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            r.run();
        }
    }
}

Use case: When tasks must eventually run and the system can tolerate slower submission.

Pros: Guarantees execution and naturally throttles new submissions.

Cons: Increases the caller’s response time because it performs the work.

3. DiscardOldestPolicy

It discards the longest‑waiting task in the queue and then retries the current task.

public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    public DiscardOldestPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            e.getQueue().poll();
            e.execute(r);
        }
    }
}

Use case: When newer tasks have higher priority and older ones can be dropped.

Pros: Allows newer, possibly more important tasks to be processed.

Cons: May discard earlier tasks, leading to inconsistent system state.

4. DiscardPolicy

This policy silently drops the rejected task without any handling.

public static class DiscardPolicy implements RejectedExecutionHandler {
    public DiscardPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        // No action taken
    }
}

Use case: When the task is non‑critical and dropping it helps maintain overall system stability.

Pros: Simple and effective, preventing task buildup and thread blockage.

Cons: Tasks are discarded silently, which may cause data loss or state inconsistency if the caller is unaware.

Understanding these policies enables developers to select the most appropriate rejection strategy based on application requirements and desired failure handling behavior.