Thread Pool Mechanism

Creating and destroying threads repeatedly introduces significant overhead when handling a large volume of concurrent tasks. A thread pool maintains a pool of reusable worker threads, eliminating the need to spawn new threads for each task. When a task arrives, its assigned to an idle thread from the pool. After completing execution, the thread returns to the pool and becomes available for subsequent tasks.

Tasks are submitted to the thread pool via the execute() or submit() methods.

Creating Thread Pools

ThreadPoolExecutor Constructor Parameters

The ThreadPoolExecutor class provides the core implementation for creating thread pools. Its constructor accepts seven parameters:

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

corePoolSize: The number of core threads that are kept alive in the pool. These threads are never recycled unless the pool is terminated.

maximumPoolSize: The maximum number of threads the pool can accommodate. When the queue is full and all core threads are busy, the pool can spawn additional threads up to this limit.

keepAliveTime: The maximum time that excess non-core threads can remain idle before being terminated. This parameter applies only when the number of threads exceeds corePoolSize.

unit: The time unit for the keepAliveTime parameter (e.g., TimeUnit.SECONDS, TimeUnit.MILLISECONDS).

workQueue: The queue used to hold tasks awaiting execution. Tasks are added to this queue when all core threads are busy. The queue implementation must be a BlockingQueue subclass, which provides blocking operations for thread-safe insertion and removal. This guarantees thread safety during queue modifications.

threadFactory: The factory used to create new threads. This allows customization of thread properties such as naming conventions and daemon status.

handler: The handler invoked when tasks cannot be executed because the pool and queue are both saturated. Java provides four built-in rejection handlers:

• AbortPolicy: Throws a RejectedExecutionException and discards the task
• DiscardPolicy: Silently discards the task without throwing an exception
• CallerRunsPolicy: Executes the task on the caller's thread instead of discarding it
• DiscardOldestPolicy: Removes the oldest unhandled task from the queue and retries executing the current task

Pre-configured Thread Pool Factories

The Executors utility class offers factory methods that instantiate common thread pool configurations:

Fixed Thread Pool: Maintains a constant number of threads

public static ExecutorService newFixedThreadPool(int threadCount) {
    return new ThreadPoolExecutor(
        threadCount,
        threadCount,
        0L,
        TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue<Runnable>()
    );
}

The core and maximum pool sizes are set to the same value, ensuring the pool always maintains the specified number of threads.

Single Thread Executor: Ensures tasks execute sequentially

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService(
        new ThreadPoolExecutor(
            1,
            1,
            0L,
            TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>()
        )
    );
}

Both pool size parameters are fixed at 1, guaranteeing that only one thread processes tasks in FIFO order.

Cached Thread Pool: Dynamically scales based on demand

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(
        0,
        Integer.MAX_VALUE,
        60L,
        TimeUnit.SECONDS,
        new SynchronousQueue<Runnable>()
    );
}

This configuration starts with zero core threads and can spawn up to Integer.MAX_VALUE temporary threads. The SynchronousQueue has no capacity, requiring a handoff to occur before new tasks are accepted. Threads idle for 60 seconds are automatically terminated.

Scheduled Thread Pool: Supports delayed and periodic task execution

public static ScheduledExecutorService newScheduledThreadPool(int coreCount) {
    return new ScheduledThreadPoolExecutor(coreCount);
}

The ScheduledThreadPoolExecutor extends ThreadPoolExecutor with scheduling capabilities:

public ScheduledThreadPoolExecutor(int coreCount) {
    super(coreCount, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

Execution Flow

The thread pool manages task distribution through a decision hierarchy:

1. Task Submission: Upon receiving a new task, the pool first checks for available idle threads. If an idle thread exists, the task is assigned immediately.

2. Core Thread Creation: If no idle threads are available, the pool evaluates whether the current active thread count is below corePoolSize. If capacity remains, a new core thread is spawned to handle the task.

3. Queue Enqueue: When core threads are fully utilized, the task is placed in the work queue. The task waits untill a thread becomes available after completing its current assignment.

4. Overflow Thread Creation: If the queue reaches capacity and the maximum thread count has not been reached, the pool creates additional temporary threads to process queued tasks. These threads are subject to the keepAliveTime timeout.

5. Rejection Handling: When both core threads, temporary threads, and queue capacity are exhausted, the rejection handler is invoked to deal with the rejected task.

Thread Pool Lifecycle States

The ThreadPoolExecutor maintains five distinct states:

Transitions between states occur automatically based on lifecycle method invocations and worker thread activity.