You are here:   HomeJava ProgrammingMultithreadingThread Pools in Java Example
by Dinesh Thakur Category: Multithreading

When a large number of threads are created, degrades the performance of your application. So Java provides a technique of thread pooling to solve this problem.

The thread pooling allows you to reuse a single thread repeatedly instead of creating a new thread for each task and allowing it to be destroyed when the task completes. It avoids the overhead associated with creating a new thread by maintaining a pool of available threads and retrieving one from the pool when necessary.

Now let us consider a program to demonstrate how thread pool is created.

import java.util.concurrent.*;

class PrintChar implements Runnable
{
    private char character;
    private int noOfTimes;
    PrintChar(char ch, int n)
    {
     character = ch ;
     noOfTimes = n ;
    }
    public void run()
    {
        for(int i=0; i<noOfTimes; i++)
             System.out.print(character+" ");
    }

  class Factorial implements Runnable
  {
          private int numberLimit;
          Factorial(int n)
            {
                     numberLimit = n;
            }
          public void run()
           {
               for(int i=1; i< numberLimit; i++)
                    System.out.print(fact(i)+" ");
           }
         long fact(int num)
          {
              if(num==0)
                   return 1;
              else
                   return(num * fact(num-1));
          }
  }
  class Threadpool
{
        public static void main(String[] args)
      {
            System.out.println("Main Thread starts");
            ExecutorService threadExecutor = Executors.newFixedThreadPool(3);
            PrintChar taskl = new PrintChar('*',50);
            PrintChar task2 = new PrintChar('S',50);
            Factorial task3 = new Factorial(10);
            threadExecutor. execute(taskl);
            threadExecutor. execute(task2);
            threadExecutor. execute(task3);
            threadExecutor.shutdown();
            while(! threadExecutor.isTerminated()){}
                   System.out.println("\nMain Thread Ends");
      }
}

Thread Pools in Java Example

In this program, we have created two classes printChar and Factorial both of which implement the Runnable interface. The PrintChar class contains the code that help to print a character a number of times. The Factorial class contains the code for calculating factorial of numbers ranging from 1 to the number specified.

In main ( ) , the statement

ExecutorService threadExecutor = Executors.newFixedThreadPool(3);

creates a threadpool executer with 3 threads in maximum.

The statement,

PrintChar taskl = new PrintChar('*',50);

creates a Runnable object taskl whose task is to print the character '* I 50 times. Similarly, two other Runnable objects task2 and task3 are created whose tasks are to print character's' fifty times and print factorial of number ranging from 1 to 10 respectively.

The statement,

threadExecutor.execute(taskl);

creates a new thread inside the ExecutorService to run the Runnable object taskl. Similarly, new threads are created fortask2 and task3 inside the ExecutorService.

The statement,

threadExecutor.shutdown();

tells the threadExecutor to shutdown. No new task can be accepted but the existing task will continue to finish.

In order to ensure that the main thread finishes last i.e. all tasks are finished before the main thread terminates, we put the statement,

while(! threadExecutor.isTerminated()){}





Subscribe To Free Daily Newsletter!

Get Free News Updates Delivered Directly To Your Inbox
About Dinesh Thakur

Dinesh ThakurDinesh Thakur holds an B.SC (Computer Science), MCSE, MCDBA, CCNA, CCNP, A+, SCJP certifications. Dinesh authors the hugely popular Computer Notes blog. Where he writes how-to guides around Computer fundamental , computer software, Computer programming, and web apps. For any type of query or something that you think is missing, please feel free to contact us.



What's New and Popular





Popular Article