Java ThreadPoolExecutor allowCoreThreadTimeOut() Method

The allowCoreThreadTimeOut() method of ThreadPoolExecutor class is used to set the policy which says that the core thread will terminate if no tasks arrive within the keep-alive time, being replaced if needed when new tasks arrive.

Syntax

Parameters

value - true if should time out, else false

Return

Does not have a return value.

Throw

IllegalArgumentException

Example 1

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecuteallowCoreThreadTimeOutExample1  {
	public static void main(String[] args) {
		//Creating a thread pool
		ThreadPoolExecutor obj = new ThreadPoolExecuteallowCoreThreadTimeOutExample1().new MyThreadExecutor(2, 3, 1,
		    TimeUnit.SECONDS, new LinkedBlockingQueue<>());
		             // obj.allowCoreThreadTimeOut();
		             //execute a runnable
		            obj.execute(() -> {
                                      System.out.println("In Runnable!");
                                           });
		                        obj.shutdown();
	                              }
    class MyThreadExecutor extends ThreadPoolExecutor {
        private final boolean allowCoreThreadTimeOut = false;
   public MyThreadExecutor(int PoolSize, int maxPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)
                          {
			        super(PoolSize, maxPoolSize, keepAliveTime, unit, workQueue);
                                this.allowCoreThreadTimeOut(false);
			        if (this.allowCoreThreadTimeOut)
                                        this.allowCoreThreadTimeOut(true);
			         else
                                      System.out.println("allowCoreThreadTimeOut  is already true");
		            }
	}
}

Test it Now

Output:

allowCoreThreadTimeOut  is already true
In Runnable!

Example 2

import java.util.concurrent.*;
 class MYThreadPoolExecutor3 extends ThreadPoolExecutor {
  public MYThreadPoolExecutor3() { 
        super(1,10,60,TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(1000));
         this.allowCoreThreadTimeOut(false);
   }
   @Override
   protected void beforeExecute(Thread thread, Runnable run){
      super.beforeExecute(thread, run);
          this.allowCoreThreadTimeOut(true);
         try {
             Object Obj = ((Future<?>) run).get();
             System.out.println(Obj);
         } catch (InterruptedException | ExecutionException e) {  }
       }
      }
  public class ThreadPoolExecuteallowCoreThreadTimeOutExample2 {
  public static void main(String args[]){
        System.out.println("creating service");
        MYThreadPoolExecutor3 obj2 = new MYThreadPoolExecutor3();
            Future<?> sb = obj2.submit(() -> {
            int a=4, b = 0;
            System.out.println("a and b="+a+":"+b);
            System.out.println("a/b:"+(a/b));
            System.out.println("Thread Name in Runnable after divide by zero:"+Thread.currentThread().getName());
        });
        obj2.shutdown();
    }
}

Test it Now

Output: