Java ExecutorService: bounded admission and shutdown

Bound the waiting work

A fixed worker count is not necessarily a bounded backlog. Some executor factory methods use an unbounded work queue, so fast producers can keep adding retained tasks even while all workers are busy.

The program configures two workers and an ArrayBlockingQueue with four waiting slots. AbortPolicy rejects excess work instead of pretending the system has unlimited capacity. RejectedExecutionException belongs in the caller’s admission policy.

A rejected task has not been accepted by this executor. Decide whether to return a busy response, retry later, or route elsewhere. An uncontrolled immediate retry loop can worsen the overload.

Observe results and stop workers

submit returns a Future. get observes the result, can throw ExecutionException for a task failure, and can be interrupted. A submitted task’s exception can go unnoticed when its Future is ignored.

shutdown stops acceptance of new tasks and lets accepted work finish. awaitTermination waits up to a chosen deadline. shutdownNow requests interruption and returns queued work that did not start; it cannot force arbitrary code to obey interruption.

The cleanup below preserves interrupt status if shutdown waiting is interrupted. The actual task is a deterministic calculation with no external effects, which keeps retry and transaction questions outside the program.

Working program

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class BoundedInvoiceWorkers {
    public static void main(String[] args) throws Exception {
        ThreadPoolExecutor workers = new ThreadPoolExecutor(
                2, 2, 0L, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<Runnable>(4), new ThreadPoolExecutor.AbortPolicy());
        try {
            Future<Integer> invoiceTotal = workers.submit(() -> 17 + 23);
            System.out.println(invoiceTotal.get());
        } finally {
            workers.shutdown();
            try {
                if (!workers.awaitTermination(2, TimeUnit.SECONDS)) workers.shutdownNow();
            } catch (InterruptedException cancelledWait) {
                workers.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }
    }
}

Output

40

Cost and design choices

The queue limits waiting tasks to four, with up to two running tasks under this fixed configuration. That is an entry-count bound, not a byte bound: each task can capture a large object graph.

Task execution cost depends on the submitted operation. This calculation is constant work. A file import or remote call may be much slower and needs timeouts, cancellation cooperation, and an overload policy suited to it.

Waiting for a Future inside another task on the same saturated pool can starve the work needed to complete it. Design dependencies explicitly rather than treating a worker pool as unlimited execution capacity.

Connected lessons

Continue with Visibility and locks, Task failure boundaries, Priority selection.

Common Mistakes

• Do not ignore Future failures.
• Do not forget shutdown in an owned executor lifecycle.
• Do not assume shutdownNow forcibly terminates every running task.
• Do not claim a fixed worker count also bounds every factory-created queue.

Apply this contract in Spring

Spring task executors: capacity, rejection and lost context. These lessons keep framework assembly separate from the Java contract.