Clase ScheduledThreadPoolExecutor

java.util.concurrent.ScheduledThreadPoolExecutor es una subclase de ThreadPoolExecutor y, además, puede programar comandos para que se ejecuten después de un retraso determinado o para que se ejecuten periódicamente.

Métodos ScheduledThreadPoolExecutor

No Señor. Método y descripción
1

protected <V> RunnableScheduledFuture<V> decorateTask(Callable<V> callable, RunnableScheduledFuture<V> task)

Modifica o reemplaza la tarea utilizada para ejecutar un invocable.
2

protected <V> RunnableScheduledFuture<V> decorateTask(Runnable runnable, RunnableScheduledFuture<V> task)

Modifica o reemplaza la tarea utilizada para ejecutar un ejecutable.
3

void execute(Runnable command)

Ejecuta el comando sin demora requerida.
4

boolean getContinueExistingPeriodicTasksAfterShutdownPolicy()

Obtiene la política sobre si continuar ejecutando las tareas periódicas existentes incluso cuando este ejecutor se ha apagado.
5

boolean getExecuteExistingDelayedTasksAfterShutdownPolicy()

Obtiene la política sobre si se deben ejecutar las tareas retrasadas existentes incluso cuando este ejecutor se ha apagado.
6

BlockingQueue<Runnable> getQueue()

Devuelve la cola de tareas utilizada por este ejecutor.
7

boolean getRemoveOnCancelPolicy()

Obtiene la política sobre si las tareas canceladas deben eliminarse inmediatamente de la cola de trabajos en el momento de la cancelación.
8

<V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)

Crea y ejecuta un ScheduledFuture que se habilita después del retraso dado.
9

ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)

Crea y ejecuta una acción de un solo paso que se habilita después del retraso dado.
10

ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)

Crea y ejecuta 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 + período, luego initialDelay + 2 * período, y así sucesivamente.
11

ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)

Crea y ejecuta una acción periódica que se habilita primero después de la demora inicial dada, y luego con la demora dada entre la terminación de una ejecución y el comienzo de la siguiente.
12

void setContinueExistingPeriodicTasksAfterShutdownPolicy (boolean value)

Establece la política sobre si continuar ejecutando tareas periódicas existentes incluso cuando este ejecutor se ha apagado.
13

void setExecuteExistingDelayedTasksAfterShutdownPolicy (boolean value)

Establece la política sobre si ejecutar las tareas retrasadas existentes incluso cuando este ejecutor se ha apagado.
14

void setRemoveOnCancelPolicy(boolean value)

Establece la política sobre si las tareas canceladas deben eliminarse inmediatamente de la cola de trabajos en el momento de la cancelación.
15

void shutdown()

Inicia un apagado ordenado en el que se ejecutan las tareas enviadas anteriormente, pero no se aceptarán nuevas tareas.
dieciséis

List<Runnable> shutdownNow()

Intenta detener todas las tareas en ejecución activa, detiene el procesamiento de las tareas en espera y devuelve una lista de las tareas que estaban en espera de ejecución.
17

<T> Future<T> submit(Callable<T> task)

Envía una tarea de devolución de valor para su ejecución y devuelve un Futuro que representa los resultados pendientes de la tarea.
18

Future<?> submit(Runnable task)

Envía una tarea ejecutable para su ejecución y devuelve un futuro que representa esa tarea.
19

<T> Future<T> submit(Runnable task, T result)

Envía una tarea ejecutable para su ejecución y devuelve un futuro que representa esa tarea.

Ejemplo

El siguiente programa TestThread muestra el uso de la interfaz ScheduledThreadPoolExecutor en un entorno basado en subprocesos.

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

public class TestThread {

   public static void main(final String[] arguments) throws InterruptedException {
      final ScheduledThreadPoolExecutor scheduler = 
         (ScheduledThreadPoolExecutor)Executors.newScheduledThreadPool(1);

      final ScheduledFuture<?> beepHandler = 
         scheduler.scheduleAtFixedRate(new BeepTask(), 2, 2, TimeUnit.SECONDS);

      scheduler.schedule(new Runnable() {

         @Override
         public void run() {
            beepHandler.cancel(true);
            scheduler.shutdown();			
         }
      }, 10, TimeUnit.SECONDS);
   }  

   static class BeepTask implements Runnable {
      
      public void run() {
         System.out.println("beep");      
      }
   }
}

Esto producirá el siguiente resultado.

Salida

beep
beep
beep
beep