ScheduledExecutorService Interface in Java

The ScheduledExecutorService interface in Java is a sub-interface of ExecutorService interface defined in java.util.concurrent package. This interface is used to run the given tasks periodically or once after a given delay. The ScheduledExecutorService interface has declared some useful methods to schedule the given tasks. These methods are implemented by the ScheduledThreadPoolExecutor class.

Declaration

public interface ScheduledExecutorService extends ExecutorService

The Hierarchy of ScheduledExecutorService

Implementing class

The implementing class of ScheduledExecutorService is ScheduledThreadPoolExecutor.

Creating a ScheduledExecutorService object

Since ScheduledExecutorService is an interface, so it can not be instantiated. But the Executors class, defined in java.util.concurrent package, provides some factory methods that return ScheduledExecutorService objects( objects of its implementing classes )

• public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) : Creates a new scheduled thread pool with a given core pool size (corePoolSize) and returns a ScheduledExecutorService object which can be downcasted to ScheduledThreadPoolExecutor object. This object can be used to run tasks after a given delay or to execute periodically.
  
• public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize , ThreadFactory threadFactory) : Creates a new scheduled thread pool with a given core pool size (corePoolSize) and returns a ScheduledExecutorService object which can be downcasted to ScheduledThreadPoolExecutor object. The second argument is a ThreadFactory object that is used when a new thread is created.

Example of ScheduledExecutorService interface : 

Java

// Java Program to demonstrate
// SchedulerExecutorService

import java.util.concurrent.*;
import java.util.*;
import java.io.*;

class SchedulerExecutorServiceExample {

    public static void main(String[] args)
    {
        System.out.println(
            "A count-down-clock program that counts from 10 to 0");

        // creating a ScheduledExecutorService object
        ScheduledExecutorService scheduler
            = Executors.newScheduledThreadPool(11);

        // printing the current time
        System.out.println(
            "Current time : "
            + Calendar.getInstance().get(Calendar.SECOND));

        // Scheduling the tasks
        for (int i = 10; i >= 0; i--) {
            scheduler.schedule(new Task(i), 10 - i,
                               TimeUnit.SECONDS);
        }

        // remember to shutdown the scheduler
        // so that it no longer accepts
          // any new tasks
        scheduler.shutdown();
    }
}

class Task implements Runnable {
    private int num;
    public Task(int num) { this.num = num; }
    public void run()
    {
        System.out.println(
            "Number " + num + " Current time : "
            + Calendar.getInstance().get(Calendar.SECOND));
    }
}

Output:

A count-down-clock program that counts from 10 to 0
Current time : 28
Number 10 Current time : 28
Number 9 Current time : 29
Number 8 Current time : 30
Number 7 Current time : 31
Number 6 Current time : 32
Number 5 Current time : 33
Number 4 Current time : 34
Number 3 Current time : 35
Number 2 Current time : 36
Number 1 Current time : 37
Number 0 Current time : 38

This is a Countdown Clock that counts from 10 to 0. The ScheduledExexutorService object i.e; scheduler is created using the Executors.newScheduledThreadPool(int corePoolSize) method. 

Note: All the tasks executed after (10 – i) seconds delay from the invocation of schedule() method. The value of the current time may vary in the output based on the time of execution.

Methods of ScheduledExecutorService

METHOD	DESCRIPTION
schedule(Runnable command, long delay, TimeUnit unit)	Submits a one-shot task that becomes enabled after the given delay.
schedule​(Callable<V> callable, long delay, TimeUnit unit)	Submits a value-returning one-shot task that becomes enabled after the given delay.
scheduleAtFixedRate​(Runnable command, long initialDelay, long period, TimeUnit unit)	Submits a periodic action that becomes enabled first after the given initial delay, and subsequently with the given period; that is, executions will commence after initialDelay, then initialDelay + period, then initialDelay + 2 * period, and so on.
scheduleWithFixedDelay​(Runnable command, long initialDelay, long delay, TimeUnit unit)	Submits a periodic action that becomes enabled first after the given initial delay, and subsequently with the given delay between the termination of one execution and the commencement of the next.

Methods declared in interface java.util.concurrent.Executor

METHOD	DESCRIPTION
execute​(Runnable command)	Executes the given command at some time in the future.

Methods declared in interface java.util.concurrent.ExecutorService

METHOD	DESCRIPTION
awaitTermination​(long timeout, TimeUnit unit)	Blocks until all tasks have completed execution after a shutdown request, or the timeout occurs, or the current thread is interrupted, whichever happens first.
invokeAll​(Collection<? extends Callable<T>> tasks)	Executes the given tasks, returning a list of Futures holding their status and results when all complete.
invokeAll​(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)	Executes the given tasks, returning a list of Futures holding their status and results when all complete or the timeout expires, whichever happens first.
invokeAny​(Collection<? extends Callable<T>> tasks)	Executes the given tasks, returning the result of one that has completed successfully (i.e., without throwing an exception), if any do.
invokeAny​(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)	Executes the given tasks, returning the result of one that has completed successfully (i.e., without throwing an exception), if any do before the given timeout elapses.
isShutdown()	Returns true if this executor has been shut down.
isTerminated()	Returns true if all tasks have completed following shut down.
shutdown()	Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted.
shutdownNow()	Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution.
submit​(Runnable task)	Submits a Runnable task for execution and returns a Future representing that task.
submit​(Runnable task, T result)	Submits a Runnable task for execution and returns a Future representing that task.
submit​(Callable<T> task)	Submits a value-returning task for execution and returns a Future representing the pending results of the task.