ThreadPoolExecutor

public ThreadPoolExecutor(
    int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue
)Code language: HTML, XML (xml)

public ThreadPoolExecutor(
    int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue,
    ThreadFactory threadFactory
)Code language: HTML, XML (xml)

public ThreadPoolExecutor(
    int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue,
    ThreadFactory threadFactory,
    RejectedExecutionHandler handler
)Code language: HTML, XML (xml)

 Parameters from above constructors

• corePoolSize: Minimum number of threads to keep in the pool.

• maximumPoolSize: Maximum number of threads allowed.

• keepAliveTime: Time to keep extra threads (above core) alive when idle.

• unit: Time unit for keepAliveTime (e.g., TimeUnit.SECONDS).

• workQueue: Queue used for holding tasks before execution (e.g., ArrayBlockingQueue, LinkedBlockingQueue).

• threadFactory: Lets you create custom threads with names, priorities, etc.
• handler: Specifies the policy for handling tasks that cannot be executed when the pool is saturated

ThreadPoolExecutor Methods in Java

The ThreadPoolExecutor class provides a wide range of control, monitoring, and customization methods for thread pool management. It extends AbstractExecutorService and implements the ExecutorService interface.

Below are its major methods grouped by functionality:

1. Task Execution

2. Lifecycle Management

3. Pool Size and Thread Management

4. Queue and Rejection Handling

5. Monitoring & Statistics

Program Implementation

//ThreadPoolExecutorDemo.java
import java.util.concurrent.*;
public class ThreadPoolExecutorDemo {
    public static void main(String[] args) {
        // Create a ThreadPoolExecutor with corePoolSize 2, maximumPoolSize 4, and a keepAliveTime of 10 seconds.
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                2, // corePoolSize
                4, // maximumPoolSize
                10, // keepAliveTime
                TimeUnit.SECONDS, // keepAliveTime unit
                new LinkedBlockingQueue<Runnable>(2) // workQueue with capacity 2
        );

        // Add a RejectedExecutionHandler to handle tasks that cannot be executed
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        for (int i = 0; i < 10; i++) {
            int taskNumber = i;
            executor.execute(() -> {
                System.out.println("Executing task " + taskNumber + " in thread " + Thread.currentThread().getName());
                try {
                    Thread.sleep(2000); // Simulate some work
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        executor.shutdown();
        try {
            if (!executor.awaitTermination(1, TimeUnit.MINUTES)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }
    }
}

/*

C:\>javac ThreadPoolExecutorDemo.java

C:\>java ThreadPoolExecutorDemo
Executing task 0 in thread pool-1-thread-1
Executing task 1 in thread pool-1-thread-2
Executing task 6 in thread main
Executing task 4 in thread pool-1-thread-3
Executing task 5 in thread pool-1-thread-4
Executing task 2 in thread pool-1-thread-1
Executing task 3 in thread pool-1-thread-3
Executing task 7 in thread pool-1-thread-2
Executing task 8 in thread pool-1-thread-4
Executing task 9 in thread pool-1-thread-4

*/

Explanation of above program,

1. Initialization: A ThreadPoolExecutor is created with a core pool size of 2, a maximum pool size of 4, and a keep-alive time of 10 seconds. The work queue is a LinkedBlockingQueue with a capacity of 2.
2. Rejection Handler: The CallerRunsPolicy rejection handler is set, which runs the task in the caller’s thread if the executor is saturated.
3. Submitting Tasks: Ten tasks are submitted to the executor. Each task prints a message and sleeps for 2 seconds to simulate work.
4. Shutdown: The shutdown() method is called to initiate an orderly shutdown. The awaitTermination method waits for all tasks to complete or a timeout to occur before shutting down.

The ThreadPoolExecutor class is the most powerful and flexible implementation of the ExecutorService interface in Java. It allows developers to manage threads efficiently by customizing thread creation, task scheduling, execution strategies, and rejection policies.

By tuning its core components—such as core pool size, maximum pool size, keep-alive time, and the task queue—you can balance resource usage and responsiveness based on application requirements. Additionally, features like custom ThreadFactory, rejection handlers, monitoring methods, and graceful shutdown mechanisms make it ideal for building scalable and responsive concurrent applications.