Mastering Java ThreadPoolExecutor: Prevent OOM and Boost Concurrency

Why Thread Pools Matter

In Java, a thread is the smallest unit of execution scheduled by the operating system, and creating or destroying threads incurs significant overhead. A thread pool pre‑creates a set of reusable threads, assigning idle ones to incoming tasks and returning them to the pool after completion, which improves resource utilization and prevents overload in high‑concurrency scenarios.

ThreadPoolExecutor Core API

The class java.util.concurrent.ThreadPoolExecutor is the primary way to create and manage a thread pool. Its constructor signature is:

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)

Key parameters:

corePoolSize : number of permanent threads that stay alive even when idle (unless allowCoreThreadTimeOut(true) is set). For CPU‑bound tasks, set to Runtime.getRuntime().availableProcessors() or slightly higher.

maximumPoolSize : upper limit of threads that can be created; choose based on system resources.

keepAliveTime and unit: idle time after which non‑core threads are terminated.

workQueue : task queue. The article recommends ArrayBlockingQueue to avoid unbounded memory growth, and warns against using LinkedBlockingQueue without a size limit.

threadFactory : custom factory to set thread names, priorities, etc.

handler : rejection policy when the queue is full and the pool cannot accept more threads.

Rejection Policies

AbortPolicy

: throws RejectedExecutionException (default). CallerRunsPolicy: the submitting thread runs the task, throttling the submission rate. DiscardPolicy: silently discards the task. DiscardOldestPolicy: discards the oldest queued task.

Typical ThreadPoolExecutor Usage (Java 21)

import java.util.concurrent.*;

public class ThreadPoolExecutorExample {
    public static void main(String[] args) {
        ThreadFactory threadFactory = Thread.ofPlatform()
            .name("worker-thread-", 1)
            .uncaughtExceptionHandler((t, e) ->
                System.err.println("Thread " + t.getName() + " uncaught: " + e))
            .factory();

        try (ExecutorService executor = new ThreadPoolExecutor(
                2,                     // corePoolSize
                5,                     // maximumPoolSize
                60L, TimeUnit.SECONDS, // keepAliveTime
                new ArrayBlockingQueue<>(10), // workQueue (bounded)
                threadFactory,
                new ThreadPoolExecutor.CallerRunsPolicy())) {

            for (int i = 0; i < 20; i++) {
                final int taskId = i;
                executor.submit(() -> {
                    try {
                        System.out.printf("Task %d executed by %s%n", taskId, Thread.currentThread().getName());
                        Thread.sleep(1000);
                        if (taskId == 15) {
                            throw new RuntimeException("Task " + taskId + " failed");
                        }
                        return "Task " + taskId + " completed";
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        throw new RuntimeException("Task interrupted", e);
                    }
                });
            }

            ThreadPoolExecutor tpe = (ThreadPoolExecutor) executor;
            System.out.printf("Active threads: %d, queued tasks: %d%n", tpe.getActiveCount(), tpe.getQueue().size());

            try {
                if (!tpe.awaitTermination(10, TimeUnit.SECONDS)) {
                    System.out.println("Tasks not finished, forcing shutdown...");
                    tpe.shutdownNow();
                }
            } catch (InterruptedException e) {
                tpe.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }
        System.out.println("Thread pool closed.");
    }
}

The program prints the execution of each task, monitors active threads and queued tasks, and demonstrates graceful shutdown with try‑with‑resources.

Problems with the Executors Factory

The Executors utility methods (e.g., newFixedThreadPool, newCachedThreadPool, newSingleThreadExecutor) create pools with unbounded queues or unlimited thread creation, which can quickly lead to Out‑Of‑Memory errors under heavy load. Alibaba’s Java Development Handbook advises avoiding these methods and using ThreadPoolExecutor directly.

Practical Recommendations

Avoid Executors factories : configure ThreadPoolExecutor explicitly.

Use bounded queues : prefer ArrayBlockingQueue with a capacity suited to your workload (e.g., 100‑1000).

Choose appropriate rejection policies : CallerRunsPolicy for throttling, AbortPolicy for fast failure, or custom handlers for logging.

Monitor pool metrics : periodically log active thread count, queue size, completed task count.

Close pools safely : wrap usage in try‑with‑resources to ensure automatic shutdown.

Configuration by Workload Type

1. High‑concurrency short‑lived tasks

Threads: corePoolSize = maximumPoolSize = 2‑4 × CPU cores Queue: bounded ArrayBlockingQueue (e.g., capacity 200)

Rejection: CallerRunsPolicy or

AbortPolicy

int cores = Runtime.getRuntime().availableProcessors();
new ThreadPoolExecutor(2*cores, 2*cores, 60L, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(200));

2. Long‑running CPU‑bound tasks

Threads: corePoolSize = CPU cores (or N+1), maximumPoolSize = N+2 Queue: small‑capacity ArrayBlockingQueue (e.g., 100)

Rejection: AbortPolicy or custom handler

int cores = Runtime.getRuntime().availableProcessors();
new ThreadPoolExecutor(cores, cores+2, 60L, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(100));

3. I/O‑bound tasks

Traditional pools can use a larger thread count (2‑10 × CPU cores) with a medium‑sized queue, or you can switch to virtual threads introduced in Java 21, which eliminate the need for manual sizing.

// Traditional pool example
int cores = Runtime.getRuntime().availableProcessors();
new ThreadPoolExecutor(2*cores, 10*cores, 60L, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(500));

// Virtual thread pool (Java 21)
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
    // submit tasks directly
}

Conclusion

Because Executors defaults to unbounded queues or unlimited threads, it can cause memory overflow and excessive system load. Using ThreadPoolExecutor with explicit parameter tuning and, for I/O‑intensive workloads, leveraging Java 21 virtual threads, reduces OOM risk and improves stability.