La interfaz ScheduledExecutorService en Java es una subinterfaz de la interfaz ExecutorService definida en el paquete java.util.concurrent . Esta interfaz se usa para ejecutar las tareas dadas periódicamente o una vez después de un retraso determinado. La interfaz ScheduledExecutorService ha declarado algunos métodos útiles para programar las tareas dadas. Estos métodos son implementados por la clase ScheduledThreadPoolExecutor .
Declaración
public interface ScheduledExecutorService extends ExecutorService
La jerarquía de ScheduledExecutorService
Clase de implementación
La clase de implementación de ScheduledExecutorService es ScheduledThreadPoolExecutor .
Creación de un objeto ScheduledExecutorService
Dado que ScheduledExecutorService es una interfaz, no se puede crear una instancia. Pero la clase Executors , definida en el paquete java.util.concurrent , proporciona algunos métodos de fábrica que devuelven objetos ScheduledExecutorService (objetos de sus clases de implementación)
- public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) : crea un nuevo grupo de subprocesos programados con un tamaño de grupo principal dado ( corePoolSize ) y devuelve un objeto ScheduledExecutorService que se puede convertir a un objeto ScheduledThreadPoolExecutor. Este objeto se puede utilizar para ejecutar tareas después de un retraso determinado o para ejecutar periódicamente.
- public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize , ThreadFactory threadFactory) : crea un nuevo grupo de subprocesos programados con un tamaño de grupo principal determinado (corePoolSize) y devuelve un objeto ScheduledExecutorService que se puede convertir a un objeto ScheduledThreadPoolExecutor. El segundo argumento es un objeto ThreadFactory que se usa cuando se crea un nuevo hilo.
Ejemplo de la interfaz ScheduledExecutorService :
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));
}
}
Producción:
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
Este es un reloj de cuenta regresiva que cuenta de 10 a 0. El objeto ScheduledExutorService, es decir; El planificador se crea mediante el método Executors.newScheduledThreadPool(int corePoolSize) .
Nota: Todas las tareas ejecutadas después de (10 – i) segundos de retraso desde la invocación del método schedule() . El valor del tiempo actual puede variar en la salida en función del tiempo de ejecución.
Métodos de ScheduledExecutorService
|
MÉTODO |
DESCRIPCIÓN |
|---|---|
| horario ( comando ejecutable , retraso largo, unidad TimeUnit ) | Envía una tarea única que se habilita después del retraso indicado. |
| horario( Callable <V> callable, long delay, unidad TimeUnit ) | Envía una tarea única que devuelve valor que se habilita después de la demora dada. |
| ScheduleAtFixedRate ( comando ejecutable, retardo inicial largo, período largo, unidad de unidad de tiempo) | Envía una acción periódica que se habilita primero después del retraso inicial dado, y luego con el período dado; es decir, las ejecuciones comenzarán después de initialDelay, luego initialDelay + period, luego initialDelay + 2 * period, y así sucesivamente. |
| ScheduleWithFixedDelay ( comando ejecutable, retraso inicial largo, retraso largo, unidad TimeUnit ) | Envía una acción periódica que se habilita primero después de la demora inicial dada y, posteriormente, con la demora dada entre la terminación de una ejecución y el comienzo de la siguiente. |
Métodos declarados en la interfaz java.util.concurrent.Executor
|
MÉTODO |
DESCRIPCIÓN |
|---|---|
| ejecutar (comando ejecutable) | Ejecuta el comando dado en algún momento en el futuro. |
Métodos declarados en la interfaz java.util.concurrent.ExecutorService
|
MÉTODO |
DESCRIPCIÓN |
|---|---|
| awaitTermination(tiempo de espera prolongado, unidad TimeUnit) | Bloquea hasta que todas las tareas hayan completado la ejecución después de una solicitud de cierre, se agote el tiempo de espera o se interrumpa el subproceso actual, lo que ocurra primero. |
| invoqueTodo(Colección<? extiende las tareas Callable<T>>) | Ejecuta las tareas dadas, devolviendo una lista de Futuros que mantienen su estado y resultados cuando todo se completa. |
| invoqueTodo(Colección<? extiende las tareas Callable<T>>, tiempo de espera prolongado, unidad TimeUnit) | Ejecuta las tareas dadas, devolviendo una lista de Futuros manteniendo su estado y resultados cuando todo se completa o expira el tiempo de espera, lo que ocurra primero. |
| invoqueCualquiera(Colección<? extiende las tareas Callable<T>>) | Ejecuta las tareas dadas, devolviendo el resultado de una que se completó con éxito (es decir, sin lanzar una excepción), si alguna lo hace. |
| invoqueCualquiera(Colección<? extiende las tareas Callable<T>>, tiempo de espera prolongado, unidad TimeUnit) | Ejecuta las tareas dadas, devolviendo el resultado de una que se completó con éxito (es decir, sin lanzar una excepción), si alguna lo hace antes de que transcurra el tiempo de espera dado. |
| esApagado() | Devuelve verdadero si este ejecutor se ha cerrado. |
| esta terminado() | Devuelve verdadero si todas las tareas se completaron después del apagado. |
| cerrar() | Inicia un apagado ordenado en el que se ejecutan las tareas enviadas anteriormente, pero no se aceptarán tareas nuevas. |
| apagar ahora() | Intenta detener todas las tareas que se están ejecutando activamente, detiene el procesamiento de las tareas en espera y devuelve una lista de las tareas que estaban esperando su ejecución. |
| enviar (tarea ejecutable) | Envía una tarea ejecutable para su ejecución y devuelve un futuro que representa esa tarea. |
| enviar (tarea ejecutable, resultado T) | Envía una tarea ejecutable para su ejecución y devuelve un futuro que representa esa tarea. |
| enviar (tarea invocable<T>) | Envía una tarea que devuelve valor para su ejecución y devuelve un futuro que representa los resultados pendientes de la tarea. |