Java ThredPoolExecutor getKeepAliveTime() Method

The getKeepAliveTime() of ThreadPoolExecutor class is used to calculate the thread keep-alive time, which is the amount of time the threads may remain idle before being terminated.

Syntax

Parameters

unit - the desired time unit of the result

Return

the time limit

Throw

Does not throw exception.

Example 1

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.lang.Thread;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
public class ThreadPoolExecutorgetKeepAliveTimeExample1  {
                 public static void main(String[] args) {
                             Task9 task1 = new Task9("t1");
                             System.out.println("Starting threads");
                     ThreadPoolExecutor tExecutor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
                     System.out.println(" Before execute Currently executing threads: "+ tExecutor.getActiveCount());
                     tExecutor.execute(task1); // start task1
                     System.out.println(" get keep alive time: "+ tExecutor.getKeepAliveTime(TimeUnit.DAYS));
                     tExecutor.shutdown(); // shutdown worker threads
                     System.out.println("Threads started, main ends\n");
                                            }
                 }
class Task9 implements Runnable {
          private final String threadName;
               public Task9(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(Task9.class.getName()).log(Level.SEVERE, null, ex);
                                  }
                                }
                           else{
                                 System.out.println(" now  i > 5 :");
                                 break;
                              }
                        }
                       }
}

Test it Now

Output:

Starting threads
 Before execute Currently executing threads: 0
 get keep alive time: 0
Threads started, main ends

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

Example 2

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

Starting threads
Threads started, main ends

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

Next TopicJava ThreadPoolExecutor

← prev next →