Customizing Thread Pool Executors

Customizing Executors

Welcome back! In the first lesson, we learned about Thread Pools and Executor Services, and how they allow efficient task execution by managing multiple threads. In this lesson, we'll be learning about the ThreadPoolExecutor, a versatile tool for optimizing thread usage in Java applications. Understanding how to customize ThreadPoolExecutor will empower you to manage your system's resources effectively.

What You'll Learn

By the end of this lesson, you will learn how to: Set up a customizable ThreadPoolExecutor with flexible parameters like core and maximum pool sizes. Implement a RejectedExecutionHandler to handle tasks when the thread pool is overloaded. Monitor the ThreadPoolExecutor to gather crucial statistics such as active thread count, task count, and pool size. These skills will not only enhance your understanding of Java's concurrency framework but also prepare you for developing highly efficient and robust applications.

ThreadPoolExecutor: A Powerful Thread Management Tool

The ThreadPoolExecutor is a highly configurable and extensible thread pool implementation that provides more flexibility than the simpler ExecutorService implementations offered by the Executors class. While ExecutorService provides basic methods for creating thread pools, ThreadPoolExecutor allows you to fine-tune important parameters, such as: The core pool size, which defines how many threads are kept alive even if they are idle. The maximum pool size, which determines the upper limit of threads that can be created to handle an increased number of tasks. The queue size, which dictates how many tasks can be waiting in line for execution. A rejected execution handler, which defines how to handle tasks that cannot be accepted when the queue is full and the pool is at maximum capacity. In addition, ThreadPoolExecutor provides useful methods to monitor the current state of the thread pool, allowing you to: Retrieve the pool size (total number of threads). Check the active thread count (how many threads are currently executing tasks). Get the task count (the number of tasks that have been submitted). This configurability makes ThreadPoolExecutor a powerful tool for efficiently managing system resources, especially in complex, multi-threaded applications. Now, let's dive into the practical implementation of customizing a ThreadPoolExecutor .

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Java

// Creating a custom ThreadPoolExecutor
ThreadPoolExecutor executor = new ThreadPoolExecutor(
        2, // core pool size
        4, // maximum pool size
        10, // keep-alive time
        TimeUnit.SECONDS, // time unit for the keep-alive time (10 seconds)
        new ArrayBlockingQueue<>(8), // work queue size
        new CustomThreadFactory(), // custom thread factory for creating new threads
        new CustomRejectedExecutionHandler() // custom handler for rejected tasks
);

// Creating a custom ThreadPoolExecutor
ThreadPoolExecutor executor = new ThreadPoolExecutor(
        2, // core pool size
        4, // maximum pool size
        10, // keep-alive time
        TimeUnit.SECONDS, // time unit for the keep-alive time (10 seconds)
        new ArrayBlockingQueue<>(8), // work queue size
        new CustomThreadFactory(), // custom thread factory for creating new threads
        new CustomRejectedExecutionHandler() // custom handler for rejected tasks
);

Java

// Submitting tasks
for (int i = 1; i <= 10; i++) {
    int taskId = i;
    executor.submit(() -> {
        System.out.println("Executing Task " + taskId + " by " + Thread.currentThread().getName());
        sleep(2000); // Simulate task processing
    });
}

// Submitting tasks
for (int i = 1; i <= 10; i++) {
    int taskId = i;
    executor.submit(() -> {
        System.out.println("Executing Task " + taskId + " by " + Thread.currentThread().getName());
        sleep(2000); // Simulate task processing
    });
}

Java

// Monitoring executor
System.out.println("Active Threads: " + executor.getActiveCount());
System.out.println("Task Count: " + executor.getTaskCount());
System.out.println("Pool Size: " + executor.getPoolSize());

executor.shutdown();

// Monitoring executor
System.out.println("Active Threads: " + executor.getActiveCount());
System.out.println("Task Count: " + executor.getTaskCount());
System.out.println("Pool Size: " + executor.getPoolSize());

executor.shutdown();

Java

import java.util.concurrent.atomic.AtomicInteger;

// Custom Thread Factory
public class CustomThreadFactory implements ThreadFactory {
    private AtomicInteger counter = new AtomicInteger(0);

    @Override
    public Thread newThread(Runnable r) {
        return new Thread(r, "CustomThread-" + counter.getAndIncrement());
    }
}

import java.util.concurrent.atomic.AtomicInteger;

// Custom Thread Factory
public class CustomThreadFactory implements ThreadFactory {
    private AtomicInteger counter = new AtomicInteger(0);

    @Override
    public Thread newThread(Runnable r) {
        return new Thread(r, "CustomThread-" + counter.getAndIncrement());
    }
}

Java

// Custom Rejected Execution Handler
public class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("Task Rejected: " + r.toString());
    }
}

// Custom Rejected Execution Handler
public class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("Task Rejected: " + r.toString());
    }
}

Java

// Creating a custom ThreadPoolExecutor
ThreadPoolExecutor executor = new ThreadPoolExecutor(
        2, // core pool size
        4, // maximum pool size
        10, // keep-alive time
        TimeUnit.SECONDS, // time unit for the keep-alive time (10 seconds)
        new ArrayBlockingQueue<>(8), // work queue size
        new CustomThreadFactory(), // custom thread factory for creating new threads
        new CustomRejectedExecutionHandler() // custom handler for rejected tasks
);

Java

// Submitting tasks
for (int i = 1; i <= 10; i++) {
    int taskId = i;
    executor.submit(() -> {
        System.out.println("Executing Task " + taskId + " by " + Thread.currentThread().getName());
        sleep(2000); // Simulate task processing
    });
}

Java

// Monitoring executor
System.out.println("Active Threads: " + executor.getActiveCount());
System.out.println("Task Count: " + executor.getTaskCount());
System.out.println("Pool Size: " + executor.getPoolSize());

executor.shutdown();

Java

import java.util.concurrent.atomic.AtomicInteger;

// Custom Thread Factory
public class CustomThreadFactory implements ThreadFactory {
    private AtomicInteger counter = new AtomicInteger(0);

    @Override
    public Thread newThread(Runnable r) {
        return new Thread(r, "CustomThread-" + counter.getAndIncrement());
    }
}

Java

// Custom Rejected Execution Handler
public class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("Task Rejected: " + r.toString());
    }
}

Customizing Executors

What You'll Learn

ThreadPoolExecutor: A Powerful Thread Management Tool

Join the 1M+ learners on CodeSignal

Creating a Custom ThreadPoolExecutor

Submitting Tasks to the Executor

Monitoring Executor

Creating a Custom Thread Factory

Implementing a Custom RejectedExecutionHandler

Why It Matters