Frequent thread creation and destruction in Java imposes significant overhead at the operating system level. While Java provides comprehensive support for thread management, handling numerous tasks by spawning a new thread per task can lead to issues such as uncontrolled thread growth and high system resource consumption.

A thread pool addresses these problems by maintaining a group of reusable threads. When tasks arrive, they are assigned to idle threads; if all threads are busy, new tasks are queued, additional threads are created (up to a limit), or the tasks are rejected. This approach offers better resource control, reduced overhead from thread lifecycle management, and improved execution efficiency.

Consider a comparison between per-task threading and thread pool usage. The following example demonstrates the performance difference:

// Per-task threading approach
public class PerTaskExample {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        java.util.Random rand = new java.util.Random();
        java.util.concurrent.CopyOnWriteArrayList<Integer> results = new java.util.concurrent.CopyOnWriteArrayList<>();
        
        for (int i = 0; i < 20000; i++) {
            new Thread(() -> results.add(rand.nextInt(100))).start();
        }
        
        while (results.size() < 20000) { /* wait */ }
        System.out.println("Per-task threading time: " + (System.currentTimeMillis() - start) + "ms");
    }
}

// Thread pool approach
public class PoolExample {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        java.util.Random rand = new java.util.Random();
        java.util.concurrent.CopyOnWriteArrayList<Integer> results = new java.util.concurrent.CopyOnWriteArrayList<>();
        
        java.util.concurrent.ThreadPoolExecutor pool = new java.util.concurrent.ThreadPoolExecutor(
            4, 4, 60, java.util.concurrent.TimeUnit.SECONDS,
            new java.util.concurrent.LinkedBlockingQueue<>(20000)
        );
        
        for (int i = 0; i < 20000; i++) {
            pool.submit(() -> results.add(rand.nextInt(100)));
        }
        
        while (results.size() < 20000) { /* wait */ }
        System.out.println("Thread pool time: " + (System.currentTimeMillis() - start) + "ms");
        pool.shutdown();
    }
}

Execution times typically show the thread pool completing tasks faster, e.g., 578ms vs. 3073ms, due to reduced thread creation overhead.

Thread pools implement the pool pattern to decouple thread creation from task execution, reusing threads to minimize resource consumption. In Java, the primary interface is Executor, with key classes including ExecutorService, ThreadPoolExecutor, and ScheduledThreadPoolExecutor. ThreadPoolExecutor is the core implementation for creating thread pools.

ThreadPoolExecutor Configuration

The ThreadPoolExecutor constructor accepts seven parameters:

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

• corePoolSize: Number of core threads that remain alive even when idle.
• maximumPoolSize: Maximum allowed threads in the pool.
• keepAliveTime: Time idle non-core threads wait before termination.
• unit: Time unit for keepAliveTime.
• workQueue: Queue for holding tasks before execution.
• threadFactory: Factory for creating new threads.
• handler: Policy for handling rejected tasks when the pool and queue are full.

Task Execution Flow

Tasks are submitted via execute() or submit() methods. The execution flow in ThreadPoolExecutor is as follows:

1. Initially, the pool contains zero threads. When a task arrives, a new thread is created if the core pool size is not reached.
2. If core threads are busy, tasks are queued in workQueue.
3. If the queue is full and the thread count is below maximumPoolSize, new threads are created.
4. If both the queue and thread limit are reached, the rejection policy is invoked.

Key methods in the execution flow include execute() for task submission, addWorker() for thread creation, runWorker() for task execution, and reject() for handling overflows.

Rejection Policies

ThreadPoolExecutor provides four built-in rejection policies:

• AbortPolicy: Throws RejectedExecutionException (default).
• DiscardPolicy: Silently discards the task.
• DiscardOldestPolicy: Removes the oldest queued task and retries execution.
• CallerRunsPolicy: Executes the task in the caller's thread.

Thread Pool States

Thread pools manage five states:

• RUNNING: Accepts new tasks and processes queued tasks.
• SHUTDOWN: Does not accept new tasks but processes existing ones.
• STOP: Does not accept new tasks and interrupts ongoing tasks.
• TIDYING: All tasks have terminated, and the pool is cleaning up.
• TERMINATED: Fully terminated.

Transitions occur via shutdown() (to SHUTDOWN), shutdownNow() (to STOP), and completion of termination steps.

Practical Usage

A typical thread pool setup involves:

java.util.concurrent.ThreadPoolExecutor executor = new java.util.concurrent.ThreadPoolExecutor(
    4, 4, 15, java.util.concurrent.TimeUnit.SECONDS,
    new java.util.concurrent.LinkedBlockingQueue<>(1000),
    java.util.concurrent.Executors.defaultThreadFactory(),
    new java.util.concurrent.ThreadPoolExecutor.AbortPolicy()
);

// Submit tasks
executor.submit(() -> { /* task logic */ });

// Shutdown when done
executor.shutdown();

The Executors utility class provides factory methods for common pool types:

1. newSingleThreadExecutor: Creates a pool with one thread and an unbounded queue.
2. newFixedThreadPool: Creates a fixed-size pool with an unbounded queue.
3. newCachedThreadPool: Creates a pool that grows as needed and threads timeout after 60 seconds.
4. newScheduledThreadPool: Creates a pool for scheduled or periodic tasks.

However, using ThreadPoolExecutor directly is recommended over Executors to avoid resource exhaustion risks from unbounded queues or excessive thread creation. Custom thread factories can be implemented for better monitoring, such as naming threads with a business-specific prefix.

Thread Count Configuration

• For CPU-intensive tasks, set thread count to N (CPU cores) + 1.
• For I/O-intensive tasks, set thread count to 2N, as threads may block on I/O operations.

Tasks involving network or file operations are typically I/O-bound; others are CPU-bound.