Why ScheduledThreadPoolExecutor is not respecting the delay?

Question

I have a Customized implementation for ScheduledThreadPoolExecutor using which I am trying to execute a task for continuous execution. The problem I have faced here with the implementation is, some tasks executed continuously where as two of them are not respecting the delay and executed continuously. I am using the scheduleWithFixedDelay method.
Even I have tried reproducing, but I couldn't.
Here is my customized implementation.
package com.portware.utils.snapmarketdata.test;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import com.indigo.utils.Log;
* To schedule the tasks in timely manner.
public class TestScheduledExecutorService  {
  private static String CLASS_NAME = TestScheduledExecutorService.class.getName();
  protected final ThreadPoolExecutor executor;
  static int totalCount = 0;
  public static void main(String[] args) throws InterruptedException {
    TestScheduledExecutorService executorService = new TestScheduledExecutorService("Test", 10, null);
    final AtomicInteger integer = new AtomicInteger();
    final Set<Integer> testSet = new HashSet<Integer>();
    for (int i = 0; i < 10; i++) {
      testSet.add(i);
    Iterator<Integer> iterator = testSet.iterator();
    synchronized (testSet) {
    while(iterator.hasNext()) {
      integer.set(iterator.next());
      executorService.submitTaskForContinuousExecution(new Runnable() {
      @Override
      public void run() {
          System.out.println(Thread.currentThread().getName()+" Hello : "+integer.get() + " count value is:"+totalCount++);
    }, integer.toString());
    while (true) {
      synchronized (TestScheduledExecutorService.class) {
        TestScheduledExecutorService.class.wait();
  private static class MyRunnableTask implements Runnable{
    ScheduledFuture<?> future;
     * The task to be run.
    private Runnable runnable;
     * The number of attempt.
    private int count;
     * Maximum attempts configured under TCA configuration.
    private int maximumAttempts;
    private String id;
    public MyRunnableTask(Runnable runnable, int maximumAttempts, String id) {
      this.runnable = runnable;
      this.maximumAttempts = maximumAttempts;
      this.id = id;
    @Override
    public void run() {
      if (count >= maximumAttempts) {
        this.future.cancel(true);
        System.out.println("Cancelling the task with id :"+id+" after count :"+count);
        return;
      count++;
      this.runnable.run();
     * Return the number of attempt.
     * @return
    public int getCount() {
      return count;
  private void submitTaskForContinuousExecution(Runnable runnable, String id){
    int numOfAttempts = 10;
    MyRunnableTask runnableTask = new MyRunnableTask(runnable, numOfAttempts, id);
    int interval = 1;
    ScheduledFuture<?> scheduleWithFixedDelay = this.scheduleWithFixedDelay(runnableTask, 0, TimeUnit.SECONDS.toMillis(interval), TimeUnit.MILLISECONDS);
    if(id != null) {
      /*System.out.println("Submitted the task for continuous execution for the ticket id :"+id+"  with maximum attempts : "+numOfAttempts
          + " and interval : "+ interval);*/
      runnableTask.future = scheduleWithFixedDelay;
   * Creates an Executor Service to provide customized execution for tasks to be scheduled.
   * @param threadName is the name that shows in logs.
   * @param maximumThreads is the number of threads can be created.
   * @param rejectedExecutionHandler is if the Queue reaches it's maximum capacity and all the executor gives
   * the tasks to rejectedExecutionHandler.
  public TestScheduledExecutorService(String threadName, int maximumThreads, RejectedExecutionHandler rejectedExecutionHandler) {
    this.executor = createExecutor(threadName, maximumThreads, rejectedExecutionHandler);
  protected ThreadPoolExecutor createExecutor(String threadName, int minimumThreads, RejectedExecutionHandler rejectedExecutionHandler) {
    ThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(minimumThreads)
      @Override
      protected void beforeExecute(Thread t, Runnable r) {
        TestScheduledExecutorService.this.beforeExecute(t, r);
        this.purge();
      @Override
      protected void afterExecute(Runnable r, Throwable t) {
        TestScheduledExecutorService.this.afterExecute(r, t);
    if(rejectedExecutionHandler != null) {
      threadPoolExecutor.setRejectedExecutionHandler(rejectedExecutionHandler);
    }else{
      threadPoolExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    threadPoolExecutor.setThreadFactory(new TestThreadFactory(threadName, threadPoolExecutor));
    threadPoolExecutor.setKeepAliveTime(120, TimeUnit.SECONDS);
    threadPoolExecutor.allowCoreThreadTimeOut(true);
    return threadPoolExecutor;
   * Executes the task repeatedly with the given delay
   * @param task
   * @param initialDelay
   * @param delay
   * @param unit
   * @return
  public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, int initialDelay, long delay, TimeUnit unit) {
    return ((ScheduledThreadPoolExecutor)executor).scheduleWithFixedDelay(task, initialDelay, delay, unit);
   * To provide threads with specific features.
  protected static class TestThreadFactory implements ThreadFactory {
    private ThreadFactory threadFactory = Executors.defaultThreadFactory();
    private ThreadPoolExecutor threadPoolExecutor;
    private String groupName;
    public TestThreadFactory(String groupName, ThreadPoolExecutor threadPoolExecutor) {
      this.groupName = groupName;
      this.threadPoolExecutor = threadPoolExecutor;
    @Override
    public Thread newThread(Runnable r) {
      Thread thread = threadFactory.newThread(r);
      int activeCount = this.threadPoolExecutor.getPoolSize();
      activeCount++;
      thread.setName(this.groupName+"-"+activeCount);
      thread.setDaemon(true);
      return thread;
   * Performs initialization tasks before starting this thread.
   * @param thread
   * @param runnable
  protected void beforeExecute(Thread thread, Runnable runnable){
   * Performs tasks after execution of this runnable.
   * @param thread
   * @param runnable
  protected void afterExecute(Runnable runnable, Throwable t){
   * Initiates an orderly shutdown in which previously submitted
   * tasks are executed, but no new tasks will be
   * accepted. Invocation has no additional effect if already shut
   * down.
  public void shutdown() {
    if(this.executor != null) {
      Log.notice(CLASS_NAME, "shutdown", "Shutting down Executor Service");
      this.executor.shutdown();
   * Attempts to stop all actively executing tasks, halts the
   * processing of waiting tasks, and returns a list of the tasks
   * that were awaiting execution. These tasks are drained (removed)
   * from the task queue upon return from this method.
   * <p>There are no guarantees beyond best-effort attempts to stop
   * processing actively executing tasks.  This implementation
   * cancels tasks via {@link Thread#interrupt}, so any task that
   * fails to respond to interrupts may never terminate.
  public List<Runnable> shutdownNow() {
   if(this.executor != null) {
     Log.notice(CLASS_NAME, "shutdownNow", "Immediately shutting down Executor Service");
     try {
      return this.executor.shutdownNow();
    } catch (Exception e) {
      Log.notice(CLASS_NAME, "shutdownNow", e.getMessage());
   return Collections.emptyList();
   * Returns a Future for the given runnable task.
  public Future<?> submit(Runnable runnable) {
    if(this.executor != null) {
      return this.executor.submit(runnable);
    return null;
Is there any possibility for the continuous execution or not?

Answer 1

I have a Customized implementation for ScheduledThreadPoolExecutor using which I am trying to execute a task for continuous execution. The problem I have faced here with the implementation is, some tasks executed continuously where as two of them are not respecting the delay and executed continuously. I am using the scheduleWithFixedDelay method.
Even I have tried reproducing, but I couldn't.
Here is my customized implementation.
package com.portware.utils.snapmarketdata.test;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import com.indigo.utils.Log;
* To schedule the tasks in timely manner.
public class TestScheduledExecutorService  {
  private static String CLASS_NAME = TestScheduledExecutorService.class.getName();
  protected final ThreadPoolExecutor executor;
  static int totalCount = 0;
  public static void main(String[] args) throws InterruptedException {
    TestScheduledExecutorService executorService = new TestScheduledExecutorService("Test", 10, null);
    final AtomicInteger integer = new AtomicInteger();
    final Set<Integer> testSet = new HashSet<Integer>();
    for (int i = 0; i < 10; i++) {
      testSet.add(i);
    Iterator<Integer> iterator = testSet.iterator();
    synchronized (testSet) {
    while(iterator.hasNext()) {
      integer.set(iterator.next());
      executorService.submitTaskForContinuousExecution(new Runnable() {
      @Override
      public void run() {
          System.out.println(Thread.currentThread().getName()+" Hello : "+integer.get() + " count value is:"+totalCount++);
    }, integer.toString());
    while (true) {
      synchronized (TestScheduledExecutorService.class) {
        TestScheduledExecutorService.class.wait();
  private static class MyRunnableTask implements Runnable{
    ScheduledFuture<?> future;
     * The task to be run.
    private Runnable runnable;
     * The number of attempt.
    private int count;
     * Maximum attempts configured under TCA configuration.
    private int maximumAttempts;
    private String id;
    public MyRunnableTask(Runnable runnable, int maximumAttempts, String id) {
      this.runnable = runnable;
      this.maximumAttempts = maximumAttempts;
      this.id = id;
    @Override
    public void run() {
      if (count >= maximumAttempts) {
        this.future.cancel(true);
        System.out.println("Cancelling the task with id :"+id+" after count :"+count);
        return;
      count++;
      this.runnable.run();
     * Return the number of attempt.
     * @return
    public int getCount() {
      return count;
  private void submitTaskForContinuousExecution(Runnable runnable, String id){
    int numOfAttempts = 10;
    MyRunnableTask runnableTask = new MyRunnableTask(runnable, numOfAttempts, id);
    int interval = 1;
    ScheduledFuture<?> scheduleWithFixedDelay = this.scheduleWithFixedDelay(runnableTask, 0, TimeUnit.SECONDS.toMillis(interval), TimeUnit.MILLISECONDS);
    if(id != null) {
      /*System.out.println("Submitted the task for continuous execution for the ticket id :"+id+"  with maximum attempts : "+numOfAttempts
          + " and interval : "+ interval);*/
      runnableTask.future = scheduleWithFixedDelay;
   * Creates an Executor Service to provide customized execution for tasks to be scheduled.
   * @param threadName is the name that shows in logs.
   * @param maximumThreads is the number of threads can be created.
   * @param rejectedExecutionHandler is if the Queue reaches it's maximum capacity and all the executor gives
   * the tasks to rejectedExecutionHandler.
  public TestScheduledExecutorService(String threadName, int maximumThreads, RejectedExecutionHandler rejectedExecutionHandler) {
    this.executor = createExecutor(threadName, maximumThreads, rejectedExecutionHandler);
  protected ThreadPoolExecutor createExecutor(String threadName, int minimumThreads, RejectedExecutionHandler rejectedExecutionHandler) {
    ThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(minimumThreads)
      @Override
      protected void beforeExecute(Thread t, Runnable r) {
        TestScheduledExecutorService.this.beforeExecute(t, r);
        this.purge();
      @Override
      protected void afterExecute(Runnable r, Throwable t) {
        TestScheduledExecutorService.this.afterExecute(r, t);
    if(rejectedExecutionHandler != null) {
      threadPoolExecutor.setRejectedExecutionHandler(rejectedExecutionHandler);
    }else{
      threadPoolExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    threadPoolExecutor.setThreadFactory(new TestThreadFactory(threadName, threadPoolExecutor));
    threadPoolExecutor.setKeepAliveTime(120, TimeUnit.SECONDS);
    threadPoolExecutor.allowCoreThreadTimeOut(true);
    return threadPoolExecutor;
   * Executes the task repeatedly with the given delay
   * @param task
   * @param initialDelay
   * @param delay
   * @param unit
   * @return
  public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, int initialDelay, long delay, TimeUnit unit) {
    return ((ScheduledThreadPoolExecutor)executor).scheduleWithFixedDelay(task, initialDelay, delay, unit);
   * To provide threads with specific features.
  protected static class TestThreadFactory implements ThreadFactory {
    private ThreadFactory threadFactory = Executors.defaultThreadFactory();
    private ThreadPoolExecutor threadPoolExecutor;
    private String groupName;
    public TestThreadFactory(String groupName, ThreadPoolExecutor threadPoolExecutor) {
      this.groupName = groupName;
      this.threadPoolExecutor = threadPoolExecutor;
    @Override
    public Thread newThread(Runnable r) {
      Thread thread = threadFactory.newThread(r);
      int activeCount = this.threadPoolExecutor.getPoolSize();
      activeCount++;
      thread.setName(this.groupName+"-"+activeCount);
      thread.setDaemon(true);
      return thread;
   * Performs initialization tasks before starting this thread.
   * @param thread
   * @param runnable
  protected void beforeExecute(Thread thread, Runnable runnable){
   * Performs tasks after execution of this runnable.
   * @param thread
   * @param runnable
  protected void afterExecute(Runnable runnable, Throwable t){
   * Initiates an orderly shutdown in which previously submitted
   * tasks are executed, but no new tasks will be
   * accepted. Invocation has no additional effect if already shut
   * down.
  public void shutdown() {
    if(this.executor != null) {
      Log.notice(CLASS_NAME, "shutdown", "Shutting down Executor Service");
      this.executor.shutdown();
   * Attempts to stop all actively executing tasks, halts the
   * processing of waiting tasks, and returns a list of the tasks
   * that were awaiting execution. These tasks are drained (removed)
   * from the task queue upon return from this method.
   * <p>There are no guarantees beyond best-effort attempts to stop
   * processing actively executing tasks.  This implementation
   * cancels tasks via {@link Thread#interrupt}, so any task that
   * fails to respond to interrupts may never terminate.
  public List<Runnable> shutdownNow() {
   if(this.executor != null) {
     Log.notice(CLASS_NAME, "shutdownNow", "Immediately shutting down Executor Service");
     try {
      return this.executor.shutdownNow();
    } catch (Exception e) {
      Log.notice(CLASS_NAME, "shutdownNow", e.getMessage());
   return Collections.emptyList();
   * Returns a Future for the given runnable task.
  public Future<?> submit(Runnable runnable) {
    if(this.executor != null) {
      return this.executor.submit(runnable);
    return null;
Is there any possibility for the continuous execution or not?