Java ThreadPoolExecutor getLargestPoolSize() Method

The getLargestPoolSize() method of ThreadPoolExecutor class returns the largest number of threads that have ever been in the pool simultaneously.

Syntax

Parameters

No parameter is passed.

Return

The number of threads.

Throw

Does not throw the exception.

Example 1

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.lang.Thread;
public class ThreadPoolExecutorgetLargestPoolSizeExample1  {
	
             public static void main(final String[] arguments) throws InterruptedException {
                           ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newCachedThreadPool();
                           System.out.println("LARGEST POOL SIZE BEFORE SUBMIT: "+ executor.getLargestPoolSize());
                           executor.submit(new Task());
                           executor.submit(new Task());
                           executor.shutdown();
                           System.out.println("LARGEST POOL SIZE AFTER SUBMIT:"+ executor.getLargestPoolSize());
                        }  

         static class Task implements Runnable {
               @Override
                public void run() {
                       try {
                           Long duration = (long) (Math.random() * 5);
                           System.out.println("Running Thread Name: " + Thread.currentThread().getName());
                           TimeUnit.SECONDS.sleep(duration);
                           System.out.println("Completed Thread Name: " +Thread.currentThread().getName());
                         } catch (InterruptedException e) {  }
                               }
                                   }
}

Test it Now

Output:

LARGEST POOL SIZE BEFORE SUBMIT: 0
LARGEST POOL SIZE AFTER SUBMIT:2
Running Thread Name: pool-1-thread-2
Running Thread Name: pool-1-thread-1
Completed Thread Name: pool-1-thread-2
Completed Thread Name: pool-1-thread-1

Example 2

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.lang.Thread;
import java.util.logging.Level;
import java.util.logging.Logger;


public class ThreadPoolExecutorgetLargestPoolSizeExample2    {
  public static void main(String[] args) {
    Task44 task1 = new Task44("t1");
    Task44 task2 = new Task44("t2");
    Task44 task3 = new Task44("t3");
  
    System.out.println("Starting threads");

    ThreadPoolExecutor tExecutor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
     System.out.println(" Before submit Largest pool size: "+ tExecutor.getLargestPoolSize());
     tExecutor.submit(task1); tExecutor.submit(task2); tExecutor.submit(task3); 
    tExecutor.execute(task1); // start task1
    tExecutor.execute(task2); // start task1
    tExecutor.execute(task3); // start task1
    System.out.println(" After submit largest pool size: "+ tExecutor.getLargestPoolSize());
    tExecutor.shutdown(); // shutdown worker threads
    System.out.println("Threads started, main ends\n");
  }
}

class Task44 implements Runnable {
  private final String threadName;
 public Task44(String threadName) {
    this.threadName = threadName;
   }
  
  @Override
  public void run() {
      for(int i=0 ; i<=10;i++)
      {
          if(i<5)
          {
              try {
                  System.out.println("Thread sleeping for 1000 i=" +i);
                  Thread.sleep(1000);
                   } catch (InterruptedException ex) {
                  Logger.getLogger(Task44.class.getName()).log(Level.SEVERE, null, ex);
              }
          }
          else{
              System.out.println(" now  i > 5 :");
              break;
          }
      }
}
}

Test it Now

Output:

Starting threads
 Before submit Largest pool size: 0
Thread sleeping for 1000 i=0
Thread sleeping for 1000 i=0
Thread sleeping for 1000 i=0
Thread sleeping for 1000 i=0
 After submit largest pool size: 6
Thread sleeping for 1000 i=0
Thread sleeping for 1000 i=0
Threads started, main ends

Thread sleeping for 1000 i=1
Thread sleeping for 1000 i=1
Thread sleeping for 1000 i=1
Thread sleeping for 1000 i=1
Thread sleeping for 1000 i=1
Thread sleeping for 1000 i=1
Thread sleeping for 1000 i=2
Thread sleeping for 1000 i=2
Thread sleeping for 1000 i=2
Thread sleeping for 1000 i=2
Thread sleeping for 1000 i=2
Thread sleeping for 1000 i=2
Thread sleeping for 1000 i=3
Thread sleeping for 1000 i=3
Thread sleeping for 1000 i=3
Thread sleeping for 1000 i=3
Thread sleeping for 1000 i=3
Thread sleeping for 1000 i=3
Thread sleeping for 1000 i=4
Thread sleeping for 1000 i=4
Thread sleeping for 1000 i=4
Thread sleeping for 1000 i=4
Thread sleeping for 1000 i=4
Thread sleeping for 1000 i=4
 now  i > 5 :
 now  i > 5 :
 now  i > 5 :
 now  i > 5 :
 now  i > 5 :
 now  i > 5 :

Next TopicJava ThreadPoolExecutor

← prev next →