Thread Pool

Java Thread Pools: Managing Concurrent Tasks Like a Pro

The Java Trail
8 min readSep 18, 2023


A thread pool is a software design pattern used in multithreaded programming to manage and reuse a group (or “pool”) of worker threads for executing tasks asynchronously. Thread pools are used to improve the efficiency and performance of applications that need to handle multiple concurrent tasks or operations, especially in situations where creating a new thread for each task would be inefficient.

Here’s why thread pools are used and their benefits:

1. Thread Creation and Destruction Overhead Reduction:

Creating and destroying threads can be a resource-intensive operation. Thread pools alleviate this overhead by maintaining a pool of pre-allocated threads. These threads are created when the pool is initialized and remain alive throughout the application’s lifecycle. When a task needs to be executed, it is assigned to an available thread from the pool. This avoids the overhead of creating and destroying threads for each task.

Analogy: Imagine a restaurant that has a pool of waiters. When a customer arrives, the restaurant assigns a waiter to take the customer’s order. The waiter takes the order and delivers it to the kitchen. Once the food is ready, the waiter picks it up and delivers it to the customer.

After the customer has finished eating, the waiter clears the table and is then available to take another order.

The restaurant’s pool of waiters is analogous to a thread pool. The waiters are the threads, and the customers are the tasks.

When a task needs to be executed, the thread pool assigns an available thread to the task. The thread executes the task and then returns to the thread pool to be reused for another task. This process of reusing threads reduces the overhead of thread creation and destruction.

2. Resource Management :

Thread pools allow you to control the number of threads available for executing tasks. This is important because having too many threads can lead to resource contention and excessive context switching, while too few threads can underutilize the available CPU cores.

Thread pool configurations typically include parameters like the minimum and maximum number of threads, which can be adjusted to optimize performance based on the workload.

Analogy: Consider a video processing application that needs to convert a large number of videos from one format to another. The application can use a thread pool to convert the videos in parallel. This can improve the performance of the application by utilizing multiple CPU cores.

The application can create a thread pool with a certain number of threads. Each thread in the pool will be responsible for converting a subset of the videos. When a thread finishes converting its subset of videos, it will return to the pool and be assigned a new subset of videos to convert.

The application can control the number of threads in the pool by setting the minimum and maximum number of threads. If the application needs to convert a large number of videos quickly, it can set the maximum number of threads to a high value. However, if the application is running on a limited-resource system, it can set the maximum number of threads to a lower value to avoid overloading the system.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class WebPageDownloader {

public static void main(String[] args) {
// Create a thread pool with a fixed number of threads (e.g., 4 threads).
ExecutorService threadPool = Executors.newFixedThreadPool(4);

// List of URLs to download concurrently.
String[] urlsToDownload = {

// Submit tasks to the thread pool for downloading web pages.
for (String url : urlsToDownload) {
threadPool.execute(() -> {

// Shutdown the thread pool when all tasks are completed.

private static void downloadWebPage(String url) {
// Simulate downloading a web page by sleeping for a random duration.
try {
System.out.println("Downloading: " + url);
Thread.sleep(2000); // Simulating a 2-second download
System.out.println("Downloaded: " + url);
} catch (InterruptedException e) {

This code will create a thread pool with a maximum of 4threads. This means that only 4tasks can be running at any given time. If we submit more than 4tasks, the remaining tasks will be queued and executed as soon as there is an available thread.

In this example:

  1. We create a WebPageDownloader class that demonstrates the use of a thread pool.
  2. We use Executors.newFixedThreadPool(4) to create a thread pool with four threads. This means that we can download up to four web pages concurrently.
  3. We have an array urlsToDownload containing the URLs of web pages we want to download concurrently.
  4. We submit tasks to the thread pool using threadPool.execute(). Each task corresponds to downloading a web page. We use a lambda expression for the task, which invokes the downloadWebPage(url) method.
  5. The downloadWebPage(url) method simulates downloading a web page by sleeping for 2 seconds (you can replace this with actual HTTP requests).
  6. Finally, we call threadPool.shutdown() to shut down the thread pool after all tasks are completed.

This example demonstrates how a thread pool efficiently manages concurrent tasks, ensuring that we can download multiple web pages concurrently while controlling the number of threads and resource utilization.

3. Load Balancing:

Thread pools help distribute tasks evenly among available idle threads. This load balancing ensures that no single thread is overwhelmed with tasks while others remain underutilized.

Analogy: Consider a web server that receives requests from multiple users at the same time. The server can use a thread pool to handle the requests in parallel. This can improve the performance of the server by utilizing multiple CPU cores.

The thread pool will assign each request to an available thread. If all of the threads are busy, the thread pool will create a new thread to handle the request. However, the thread pool can limit the maximum number of threads that can be created. This prevents the server from creating too many threads and overwhelming its resources.

4. Improved Responsiveness:

In applications with a user interface (e.g., GUI applications or web servers), thread pools can prevent the UI from becoming unresponsive when executing time-consuming tasks. By offloading these tasks to worker threads in the pool, the main UI thread remains free to handle user interactions.

Problem Statement: Imagine you’re developing a GUI application that needs to parse a large JSON file and display the parsed result to the user. Parsing a large JSON file can be a time-consuming operation, and if done on the main UI thread, it can make the application appear unresponsive to the user.

Solution with Thread Pool: To keep the GUI responsive, we can use a thread pool to offload the JSON parsing task to a separate worker thread. This way, the main UI thread can continue handling user interactions while the parsing takes place in the background. Once the parsing is complete, the result can be safely updated in the UI.

Here’s a Java example code that demonstrates this concept using a Swing GUI:

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class JSONParserGUI extends JFrame {

private JTextArea resultTextArea;
private JButton parseButton;

public JSONParserGUI() {
setTitle("JSON Parser GUI");
setSize(400, 300);

resultTextArea = new JTextArea();
JScrollPane scrollPane = new JScrollPane(resultTextArea);

parseButton = new JButton("Parse JSON");
parseButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// When the "Parse JSON" button is clicked, start JSON parsing in a worker thread.

getContentPane().setLayout(new BorderLayout());
getContentPane().add(parseButton, BorderLayout.NORTH);
getContentPane().add(scrollPane, BorderLayout.CENTER);

private void parseJSONInBackground() {
ExecutorService threadPool = Executors.newSingleThreadExecutor();

threadPool.execute(() -> {
// Simulate JSON parsing (replace with actual parsing logic).
String parsedResult = simulateJSONParsing();

// Update the UI with the parsed result on the Event Dispatch Thread.
SwingUtilities.invokeLater(() -> {

// Shutdown the thread pool after the task is complete.

private String simulateJSONParsing() {
// Simulate JSON parsing (replace with your actual parsing logic).
// This can be a time-consuming operation.
try {
Thread.sleep(3000); // Simulating a 3-second parsing operation
} catch (InterruptedException e) {

return "Parsed JSON result goes here.";

public static void main(String[] args) {
SwingUtilities.invokeLater(() -> {
JSONParserGUI gui = new JSONParserGUI();

In this example:

  • We create a simple Swing GUI application with a text area for displaying the parsed JSON result and a “Parse JSON” button to initiate parsing.
  • When the “Parse JSON” button is clicked, the parseJSONInBackground method is called. It creates a single-threaded executor (thread pool) and submits the JSON parsing task to it.
  • The simulateJSONParsing method simulates a time-consuming JSON parsing operation.
  • Once the parsing is complete, we use SwingUtilities.invokeLater to safely update the UI with the parsed result on the Event Dispatch Thread (EDT). This ensures that GUI updates are performed on the EDT, preventing GUI-related concurrency issues.
  • Finally, we start the GUI application by invoking SwingUtilities.invokeLater in the main method to ensure proper GUI initialization.

By using a thread pool and executing the JSON parsing task in the background, we prevent the GUI from becoming unresponsive during the parsing operation, providing a more responsive and user-friendly experience.

Fault tolerance

Fault tolerance in the context of thread pools refers to the ability of a thread pool to handle unexpected exceptions that occur during task execution in a way that prevents the entire application from crashing. Instead of allowing a single failed task to bring down the entire application, a fault-tolerant thread pool can isolate and recover from exceptions, ensuring that other tasks continue to run.

Real-Life Example: Image Processing Pipeline

Imagine you are developing an image processing pipeline application. This application accepts images, applies various image processing tasks (e.g., resizing, filtering, and watermarking), and then stores or displays the processed images.

In this application, you use a thread pool to parallelize the image processing tasks to improve performance. However, image processing tasks can sometimes encounter exceptions, such as when an image file is corrupted or when there’s insufficient memory to process an image.

Here’s how fault tolerance with a thread pool can be applied in this scenario:

Configuring a Fault-Tolerant Thread Pool: You create a thread pool with fault tolerance features. Java’s ThreadPoolExecutor can be configured to handle exceptions by providing a custom ThreadFactory and overriding the uncaughtException method of threads.

ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
corePoolSize, // Minimum number of threads
maxPoolSize, // Maximum number of threads
keepAliveTime, // Thread idle time
TimeUnit.SECONDS, // Time unit
new LinkedBlockingQueue<>(), // Task queue
new FaultTolerantThreadFactory()); // Custom ThreadFactory

Implementing Fault Tolerance: You implement fault tolerance mechanisms within the uncaughtException method of the custom thread factory. When an unhandled exception occurs in a worker thread, this method is invoked.

class FaultTolerantThreadFactory implements ThreadFactory {
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setUncaughtExceptionHandler((thread, throwable) -> {
// Handle the exception here (e.g., log it).
// Optionally, replace the failed thread with a new one.
return t;

private void createAndStartNewThread(Runnable task) {
Thread newThread = new Thread(task);

Example Exception Handling: When an image processing task encounters an exception (e.g., due to a corrupted image), the exception is caught, logged, and not propagated to the main application thread. Instead, the fault-tolerant thread pool’s uncaughtException method handles it.

Continued Operation: Despite the exception in one task, the thread pool continues to operate, processing other image tasks in other threads without affecting the application’s overall stability.

By configuring your thread pool with fault tolerance features and implementing custom exception handling, you ensure that your image processing application remains resilient in the face of exceptions. This allows it to continue processing other images and providing a responsive user experience even when individual tasks encounter errors.



The Java Trail

Scalable Distributed System, Backend Performance Optimization, Java Enthusiast. ( Or, +8801741240520)