Java ThreadPoolExecutor getPoolSize() Method

The getPoolSize() method of ThreadPoolExecutor class returns the current number of threads in the pool.

Syntax

Parameters

No parameter is passed.

Return

The number of threads

Throw

Does not throw exception.

Example 1

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.lang.Thread;
public class ThreadPoolExecutorgetPoolSizeExample1  {
	
      public static void main(final String[] arguments) throws InterruptedException {
                     ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newCachedThreadPool();
                     executor.submit(new Task());
                     System.out.println("POOL SIZE : "+ executor.getPoolSize());
                     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:

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

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 ThreadPoolExecutorgetPoolSizeExample2 {
       public  static void main(String[] args) {
                 Task46 task1 = new Task46("t1");
                 Task46 task2 = new Task46("t2");
                 System.out.println("Starting threads");
                 ThreadPoolExecutor tExecutor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
                 System.out.println("  Maximum pool size: "+ tExecutor.getMaximumPoolSize());
                 tExecutor.submit(task1); tExecutor.submit(task2); 
                 tExecutor.execute(task1); // start task1
                 tExecutor.execute(task2); // start task2    
                 System.out.println(" After submit  pool size: "+ tExecutor.getPoolSize());
                 tExecutor.shutdown(); // shutdown worker threads
                 System.out.println("Threads started, main ends\n");
                 }
       }

 class Task46 implements Runnable {
                   private final String threadName;
                   public Task46(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(Task46.class.getName()).log(Level.SEVERE, null, ex);
                          }
                        }
                      else{
                         System.out.println(" now  i > 5 :");
                         break;
                     }
               }
          }
}

Test it Now

Output:

Starting threads
  Maximum pool size: 2147483647
Thread sleeping for 1000 i=0
Thread sleeping for 1000 i=0
Thread sleeping for 1000 i=0
 After submit  pool size: 4
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=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=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 :

Next TopicJava ThreadPoolExecutor

← prev next →