ScheduledExecutorService Interface in Java

ScheduledExecutorService is used to schedule tasks to run after a delay or at fixed intervals in Java. It is part of the java.util.concurrent package and extends ExecutorService. It helps in managing background and periodic task execution efficiently.

• Executes tasks after delay or periodically
• Uses thread pool for better performance
• More flexible and reliable than Timer

Declaration

public interface ScheduledExecutorService extends ExecutorService

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

Explanation: This example demonstrates a countdown clock from 10 to 0 using ScheduledExecutorService. A scheduler is created using Executors.newScheduledThreadPool(), and tasks are scheduled with delays of (10 - i) seconds.

Note: Execution time may vary depending on the system clock.

The Hierarchy of ScheduledExecutorService

It extends ExecutorService, which extends Executor, enabling scheduling of tasks with delays or at fixed intervals.

Implementing class: The implementing class of ScheduledExecutorService is ScheduledThreadPoolExecutor.

Creating a ScheduledExecutorService Object

• ScheduledExecutorService is an interface, so it cannot be instantiated directly.
• The Executors class (from java.util.concurrent package) provides factory methods to create its objects.

Factory (Overloaded)Methods of ScheduledExecutorService:

1.newScheduledThreadPool(int corePoolSize)

• Creates a scheduled thread pool with the given corePoolSize
• Returns a ScheduledExecutorService object
• This object can be downcasted to ScheduledThreadPoolExecutor
• Used to: Execute tasks after a delay and Execute tasks periodically

Syntax:

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

2. newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

• Creates a scheduled thread pool with the given corePoolSize
• Returns a ScheduledExecutorService object
• The ThreadFactory: Is used to create new threads and Allows customization (thread name, priority, etc.)
• Can also be downcasted to ScheduledThreadPoolExecutor

Syntax:

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

Methods of ScheduledExecutorService

Methods declared in interface java.util.concurrent.Executor

Methods declared in interface java.util.concurrent.ExecutorService