Executor Framework

🔍 What Is It?

Executor hierarchy:

Executor
└── ExecutorService
    ├── AbstractExecutorService
    │   └── ThreadPoolExecutor (the main implementation)
    │       └── ScheduledThreadPoolExecutor
    └── ForkJoinPool (work-stealing, for parallel streams)

Factory methods (Executors class):

• →newFixedThreadPool(n) — fixed n threads, unbounded queue
• →newCachedThreadPool() — grows as needed, idle threads expire after 60s
• →newSingleThreadExecutor() — one thread, tasks run sequentially
• →newScheduledThreadPool(n) — for scheduled/periodic tasks
• →newVirtualThreadPerTaskExecutor() — virtual thread per task (Java 21)
• →newWorkStealingPool() — ForkJoinPool with parallelism = CPU count

ThreadPoolExecutor parameters:

• →corePoolSize — minimum threads kept alive
• →maximumPoolSize — maximum threads allowed
• →keepAliveTime — how long idle threads above core survive
• →workQueue — queue for pending tasks (LinkedBlockingQueue, SynchronousQueue, ArrayBlockingQueue)
• →threadFactory — how threads are created (set names here!)
• →rejectedExecutionHandler — what to do when queue is full

🎯 Why Do We Need It?

Without a thread pool:

• →Creating a new thread for each task is expensive (1MB stack allocation, OS thread creation)
• →Unlimited thread creation exhausts memory and OS resources
• →No control over concurrency level

With a thread pool:

• →Threads are reused across tasks
• →Concurrency is bounded (no resource exhaustion)
• →Queue provides backpressure
• →Monitoring and management are centralized

🏗️ What Happens in Real Projects?

In Spring Boot, configure thread pools as beans:

@Configuration
public class AsyncConfig implements AsyncConfigurer {
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(50);
        executor.setQueueCapacity(500);
        executor.setThreadNamePrefix("async-");
        executor.initialize();
        return executor;
    }
}

⚙️ How It Works

Task Submission Flow:

1. Task submitted to ExecutorService
2. If corePoolSize not reached: create new thread
3. If corePoolSize reached: add to queue
4. If queue full: create new thread (up to maximumPoolSize)
5. If maximumPoolSize reached and queue full: apply rejection policy

Rejection Policies:

• →AbortPolicy (default) — throw RejectedExecutionException
• →CallerRunsPolicy — run in the calling thread (backpressure)
• →DiscardPolicy — silently discard
• →DiscardOldestPolicy — discard oldest queued task

Sizing thread pools:

• →CPU-bound: threads = CPU cores (no benefit from more)
• →I/O-bound: threads = CPU cores * (1 + wait_time/compute_time) — more threads to cover I/O wait

💻 Example

Thread Pool Configuration for Production — How to configure and use thread pools in enterprise Java.

// Production-grade thread pool configuration
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    10,                          // corePoolSize: always keep 10 threads
    50,                          // maximumPoolSize: max 50 threads
    60, TimeUnit.SECONDS,        // keepAliveTime: idle threads above core expire after 60s
    new LinkedBlockingQueue<>(500), // queue capacity: buffer 500 tasks
    new ThreadFactory() {
        private final AtomicInteger counter = new AtomicInteger(0);
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, "order-processor-" + counter.incrementAndGet());
            t.setDaemon(false);
            t.setUncaughtExceptionHandler((thread, ex) ->
                log.error("Uncaught exception in {}: {}", thread.getName(), ex.getMessage(), ex)
            );
            return t;
        }
    },
    new ThreadPoolExecutor.CallerRunsPolicy()  // backpressure when full
);

// Monitor the pool
ScheduledExecutorService monitor = Executors.newSingleThreadScheduledExecutor();
monitor.scheduleAtFixedRate(() -> {
    log.info("Pool: active={}, queued={}, completed={}, poolSize={}",
        executor.getActiveCount(),
        executor.getQueue().size(),
        executor.getCompletedTaskCount(),
        executor.getPoolSize()
    );
}, 0, 30, TimeUnit.SECONDS);

// Graceful shutdown
Runtime.getRuntime().addShutdownHook(new Thread(() -> {
    log.info("Shutting down executor...");
    executor.shutdown();
    try {
        if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
            log.warn("Executor did not terminate gracefully, forcing shutdown");
            executor.shutdownNow();
        }
    } catch (InterruptedException e) {
        executor.shutdownNow();
        Thread.currentThread().interrupt();
    }
}));

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits