Java ThreadPoolExecutor getCorePoolSize() Method

The getCorePoolSize() method of ThreadPoolExecutor class is used to calculate the approximate number of threads that are actively executing tasks.

Syntax

Parameters

Returns

The number of threads

Throw

Example 1

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.lang.Thread;
public class ThreadPoolExecutorgetCorePoolsizeExample1  {
 public static void main(final String[] arguments) throws InterruptedException {
             ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newCachedThreadPool();
             executor.submit(new Task());
             executor.submit(new Task());
             System.out.println("Core Pool size after execution: " + executor.getCorePoolSize());
             executor.shutdown();
             }  

 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:

Core Pool size after execution: 0
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 ThreadPoolExecutorgetCorePoolsizeExample2   {
                   public static void main(String[] args) {
                                  Task7 task1 = new Task7("t1");
                                  Task7 task2 = new Task7("t2");
                                  System.out.println("Starting threads");
                          ThreadPoolExecutor tExecutor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
                          tExecutor.execute(task1); tExecutor.execute(task2); // start task1
                          System.out.println(" After execute Core pool size : "+ tExecutor.getCorePoolSize());
                          tExecutor.shutdown(); // shutdown worker threads
                          System.out.println("Threads started, main ends\n");
                            }
                   }

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

Test it Now

Output:

Starting threads
 After execute Core pool size : 0
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=2
Thread sleeping for 1000 i=2
Thread sleeping for 1000 i=3
Thread sleeping for 1000 i=3
Thread sleeping for 1000 i=4
Thread sleeping for 1000 i=4
 now  i > 5 :
 now  i > 5 :

Next TopicJava ThreadPoolExecutor

← prev next →