Java ThreadPoolExecutor getTaskCount() Method

The getTaskCount() returns the approximate total number of tasks that have ever been scheduled for the execution. Because, the states of tasks and threads may change dynamically during computation, the returned value is only an approximation.

Syntax

Parameters

No parameter is passed.

Return

The number of tasks

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 ThreadPoolExecutorgetTaskCountExample1  {
	
    public static void main(final String[] arguments) throws InterruptedException {
                ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newCachedThreadPool();
                executor.submit(new Task());
                System.out.println("get Task count before:"+ executor.getTaskCount());
                executor.submit(new Task());
                executor.shutdown();
                System.out.println("get Task count after:"+ executor.getTaskCount());
              }  

      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:

get Task count before:1
get Task count after:2
Running Thread Name: pool-1-thread-1
Running Thread Name: pool-1-thread-2
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 ThreadPoolExecutorgetTaskCountExample2{
  public static void main(String[] args) {
    Work25 task1 = new Work25("t1");
    Work25 task2 = new Work25("t2");
    
  
    System.out.println("Starting threads");

    ThreadPoolExecutor tExecutor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
     System.out.println("  Maximum pool size: "+ tExecutor.getMaximumPoolSize());
      System.out.println("get Task count before:"+ tExecutor.getTaskCount());
     tExecutor.submit(task1); tExecutor.submit(task2); 
    tExecutor.execute(task1); // start task1
    tExecutor.execute(task2); // start task2    
  System.out.println("get Task count after:"+ tExecutor.getTaskCount());
    tExecutor.shutdown(); // shutdown worker threads

    System.out.println("Threads started, main ends\n");
  }
}

 class Work25 implements Runnable {
 
 private final String threadName;

  public Work25(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(Work25.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
get Task count before:0
Thread sleeping for 1000 i=0
Thread sleeping for 1000 i=0
Thread sleeping for 1000 i=0
get Task count after:4
Threads started, main ends

Thread sleeping for 1000 i=0
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 →