Introduction to Java Thread Pool
A thread pool, like the name, suggests is a collection of threads that can be reused. These threads have been created previously and can also function with offering solution to overheads. When there is already a collection of threads available these can be reused and resolve the issue of thread cycles and waiting for threads to complete their task. As the thread will already be existing whenever the request arrives it will remove the process of thread creation and as a result save that time and make the processing faster. In this topic, we are going to learn about Java Thread Pool.
Working of Java Thread Pool
All threads in thread pools implement the methods from java.util.concurrent. There is a thread pool that is managed by the Java thread pool. The easiest way of seeing this pool is the more threads you make use of the less time each thread will spend upon doing the actual work. It is a way that helps in saving resources in an application where multi-threading can be used. There is a queue which is maintained by this Java thread for pools.
The worker threads keep waiting for tasks to be assigned and get them executed. To create a thread pool ThreadPoolExecutor is used in Java. The collection of runnable threads are responsible for managing the threads in the Java Thread pool. After this, the worker threads come in picture and form queues. These queues are monitored by the thread pool.
The java.util.concurrent.Executors helps us with the factory and support methods that are needed for managing the threads. This class is also responsible for creating the thread pool. Now your next question might be what is this Executor? Executor provides different classes which are a part of the utility class.
The technical working of thread pool can be thought of like a pool where you have your concurrent code which is split into tasks that can run in parallel. Then they are submitted for execution to the pool. There are task submitters, Executor Services, task queues, and in the end the thread pool. The pattern can help you in controlling the number of threads that are present in the application. It decides its lifecycle, schedules the tasks, and keeps the tasks incoming in the work queue.
The Executorshelper class has various methods that have pre-configured thread pool instances. The Executor and ExecutorService interfaces help in working with different implementation in the pool. The code must be in the decoupled format before the actual implementation. There is another interface that is used. It is a ThreadPoolExecutor. It is an extensible thread pool implementation where many parameters can be specified and it will result in fine-tuning. The parameters which can be used include core pool size, maximum pool size, and keepalive time. The queue can grow only up to the maximum pool size.
Example of Java Thread Pool
Let us create a pool and see how it works.
// The Job class will be executed in this case
class Job implements Runnable
private String name;
public Job(String s)
name = s;
// The task name will be populated first for the ones which were not running already, and the thread will sleep for 2s
//This entire method will be repeated 6 times
public void run()
for (int i = 0; i<=5; i++)
Date d = new Date();
System.out.println("We are in "
+ " task name - "+ name);
//prints the task name every time the new task is started
System.out.println("The job "+
name +" is already running ");
// prints the job name which is already running
Thread.sleep(2000); // The thread is in sleep mode for 2 secs
System.out.println(name+" job is completes");
public class Test
// Here we define the maximum threads we have
static final int MAX_Threads= 5;
public static void main(String args)
Runnable run1 = new Job("task 1");
Runnable run2 = new Job("task 2");
Runnable run3 = new Job("task 3");
//A new thread pool is created with maximum number of threads
ExecutorService newpool = Executors.newFixedThreadPool(MAX_Threads);
The above code covers each step of the creation of thread till its shutdown. There is a maximum thread limit fixed and created. Once this is done there are three jobs created which execute one by one. There is also a sleep time allotted for 2 secs for each job. As the thread pool is created and all jobs work simultaneously, we can see that this entire process will run 6 times. When the if statement runs in thread pool it checks if the job is already running or not. If the job has not started running it will execute the if block. If it is already running, then the else block will be run. It will display the job name and say that it is already running. The thread pool is created and then all 3 jobs are run. Once the jobs are run we shut down the thread pool that we have created.
Below will be the output of the given program.
It runs until all tasks are completed.
Advantages and Disadvantages of Thread Pools
We have several advantages of Thread Pool in Java. To name a few below are the main advantages:
- It results in better and efficient performance of the CPU and program.
- As all processes are being worked by different threads, it saves time.
- The main advantage of the thread pool is the reuse of threads which are already present. There is no need of creating new threads again and again.
- It provides real-time access which helps in working with real-time data.
We also have some disadvantages of thread pool though. Below are the disadvantages:
- You cannot set the priority of tasks and also these cannot be tracked.
- When used more these can be deleted automatically.
As a result thread pools are an efficient way of handling the multiple tasks which we have at our hand. Java provides us with the facility of reusing the threads and making use of the existing resources.
This is a guide to Java Thread Pool. Here we discuss the working of Java Thread Pool, programming examples along with the advantages and disadvantages. You may also have a look at the following articles to learn more –