Clase ScheduledThreadPoolExecutor en Java

La clase ScheduledThreadPoolExecutor en Java es una subclase de la clase ThreadPoolExecutor definida en el paquete java.util.concurrent. Como queda claro por su nombre, esta clase es útil cuando queremos programar tareas para que se ejecuten repetidamente o para que se ejecuten después de un retraso determinado en el futuro. Crea un Thread Pool de tamaño fijo. Entonces, cuando se inicia, se le debe dar el corePoolSize (la cantidad de subprocesos en el grupo de subprocesos ).

Jerarquía de clases: 

Constructores:

• ScheduledThreadPoolExecutor(int corePoolSize) : crea un nuevo objeto ScheduledThreadPoolExecutor con el tamaño de grupo dado. Debe tenerse en cuenta que crea un conjunto de subprocesos de tamaño fijo, por lo que una vez que se proporciona corePoolSize, no se puede aumentar el tamaño del conjunto de subprocesos.
• ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory) : crea un nuevo objeto ScheduledThreadPoolExecutor con los parámetros proporcionados. El primer parámetro es el tamaño del grupo de subprocesos y el segundo parámetro es un objeto ThreadFactory que se usa cuando ScheduledThreadPoolExecutor crea un nuevo subproceso.
• ScheduledThreadPoolExecutor(int corePoolSize, RejectedExecutionHandler handler) : crea un nuevo objeto ScheduledThreadPoolExecutor con el corePoolSize(tamaño de ThreadPool) dado y el controlador que se usa cuando se rechaza la ejecución de una tarea (cuando la cola de trabajo está llena o la ejecución está bloqueada).
• ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory, RejectedExecutionHandler handler) : crea un nuevo objeto ScheduledThreadPoolExecutor con los parámetros proporcionados.

Además de estos constructores, existe otra forma de obtener un objeto ScheduledThreadPoolExecutor. Podemos usar el método de fábrica Executors.newScheduledThreadPool(int corePoolSize) definido por la clase Executors. Devuelve un objeto ScheduledExecutorService que se puede convertir al objeto ScheduledThreadPoolExecutor.

ScheduledThreadPoolExecutor threadPool = (ScheduledThreadPoolExecutor)Executors.newScheduledThreadPool(4);

Ejemplo 1 :

// Java program to demonstrates ScheduleThreadPoolExecutor
// class
import java.util.*;
import java.util.concurrent.*;
import java.io.*;
  
class GFG {
    public static void main(String[] args)
    {
  
        // Creating a ScheduledThreadPoolExecutor object
        ScheduledThreadPoolExecutor threadPool
            = new ScheduledThreadPoolExecutor(2);
  
        // Creating two Runnable objects
        Runnable task1 = new Command("task1");
        Runnable task2 = new Command("task2");
  
        // Printing the current time in seconds
        System.out.println(
            "Current time : "
            + Calendar.getInstance().get(Calendar.SECOND));
  
        // Scheduling the first task which will execute
        // after 2 seconds
        threadPool.schedule(task1, 2, TimeUnit.SECONDS);
  
        // Scheduling the second task which will execute
        // after 5 seconds
        threadPool.schedule(task2, 5, TimeUnit.SECONDS);
  
        // Remember to shut sown the Thread Pool
        threadPool.shutdown();
    }
}
  
// Class that implements the Runnable interface
class Command implements Runnable {
    String taskName;
    public Command(String taskName)
    {
        this.taskName = taskName;
    }
    public void run()
    {
        System.out.println(
            "Task name : " + this.taskName + " Current time: "
            + Calendar.getInstance().get(Calendar.SECOND));
    }
}

Salida :

Current time : 51
Task name : task1 Current time : 53
Task name : task2 Current time : 56

Aquí la primera tarea se ejecuta después de un retraso de dos segundos y la segunda tarea se ejecuta después de los cinco segundos.

Ejemplo 2 :

// Java program to demonstrates ScheduleThreadPoolExecutor
// class
import java.util.*;
import java.util.concurrent.*;
import java.io.*;
  
class GFG {
    public static void main(String[] args)
    {
  
        // Creating a ScheduledThreadPoolExecutor object
        ScheduledThreadPoolExecutor threadPool
            = new ScheduledThreadPoolExecutor(2);
  
        // Creating two Runnable objects
        Runnable task1 = new Command("task1");
        Runnable task2 = new Command("task2");
  
        // Printing the current time in seconds
        System.out.println(
            "Current time:"
            + Calendar.getInstance().get(Calendar.SECOND));
  
        // Scheduling the first task which will execute
        // after 2 seconds and then repeats periodically with
        // a period of 8 seconds
        threadPool.scheduleAtFixedRate(task1, 2, 8,
                                       TimeUnit.SECONDS);
  
        // Scheduling the second task which will execute
        // after 5 seconds and then there will be a delay of
        // 5 seconds between the completion
        // of one execution and the commencement of the next
        // execution
        threadPool.scheduleWithFixedDelay(task2, 5, 5,
                                          TimeUnit.SECONDS);
  
        // Wait for 30 seconds
        try {
            Thread.sleep(30000);
        }
        catch (Exception e) {
            e.printStackTrace();
        }
  
        // Remember to shut sown the Thread Pool
        threadPool.shutdown();
    }
}
  
// Class that implements Runnable interface
class Command implements Runnable {
    String taskName;
    public Command(String taskName)
    {
        this.taskName = taskName;
    }
    public void run()
    {
        try {
            System.out.println("Task name : "
                               + this.taskName
                               + " Current time : "
                               + Calendar.getInstance().get(
                                     Calendar.SECOND));
            Thread.sleep(2000);
            System.out.println("Executed : " + this.taskName
                               + " Current time : "
                               + Calendar.getInstance().get(
                                     Calendar.SECOND));
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Salida :

Current time:26
Task name : task1 Current time : 28
Executed : task1 Current time : 30
Task name : task2 Current time : 31
Executed : task2 Current time : 33
Task name : task1 Current time : 36
Executed : task1 Current time : 38
Task name : task2 Current time : 38
Executed : task2 Current time : 40
Task name : task1 Current time : 44
Task name : task2 Current time : 45
Executed : task1 Current time : 46
Executed : task2 Current time : 47
Task name : task1 Current time : 52
Task name : task2 Current time : 52
Executed : task1 Current time : 54
Executed : task2 Current time : 54

Aquí, la primera tarea se ejecutará después de los dos segundos y luego se repetirá periódicamente después de los ocho segundos. La segunda tarea se ejecutará después de los cinco segundos y luego habrá un retraso de cinco segundos entre la finalización de una ejecución y el comienzo de la siguiente ejecución.

Métodos