Classe ScheduledThreadPoolExecutor

java.util.concurrent.ScheduledThreadPoolExecutor é uma subclasse de ThreadPoolExecutor e pode, adicionalmente, agendar comandos para serem executados após um determinado atraso ou periodicamente.

Métodos ScheduledThreadPoolExecutor

Sr. Não. Método e Descrição
1

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

Modifica ou substitui a tarefa usada para executar um chamável.
2

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

Modifica ou substitui a tarefa usada para executar um executável.
3

void execute(Runnable command)

Executa o comando com zero de atraso necessário.
4

boolean getContinueExistingPeriodicTasksAfterShutdownPolicy()

Obtém a política de continuar executando as tarefas periódicas existentes, mesmo quando o executor foi desligado.
5

boolean getExecuteExistingDelayedTasksAfterShutdownPolicy()

Obtém a política de execução de tarefas atrasadas existentes, mesmo quando o executor foi desligado.
6

BlockingQueue<Runnable> getQueue()

Retorna a fila de tarefas usada por este executor.
7

boolean getRemoveOnCancelPolicy()

Obtém a política sobre se as tarefas canceladas devem ser removidas imediatamente da fila de trabalho no momento do cancelamento.
8

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

Cria e executa um ScheduledFuture que é ativado após um determinado atraso.
9

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

Cria e executa uma ação instantânea que é ativada após um determinado atraso.
10

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

Cria e executa uma ação periódica que é habilitada primeiro após o atraso inicial fornecido e, subsequentemente, com o período determinado; isto é, as execuções começarão após initialDelay, initialDelay + período, initialDelay + 2 * período e assim por diante.
11

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

Cria e executa uma ação periódica que é habilitada primeiro após o atraso inicial fornecido e, subsequentemente, com o atraso fornecido entre o término de uma execução e o início da próxima.
12

void setContinueExistingPeriodicTasksAfterShutdownPolicy (boolean value)

Define a política de continuar ou não a execução das tarefas periódicas existentes, mesmo quando este executor foi desligado.
13

void setExecuteExistingDelayedTasksAfterShutdownPolicy (boolean value)

Define a política de execução de tarefas atrasadas existentes, mesmo quando este executor foi desligado.
14

void setRemoveOnCancelPolicy(boolean value)

Define a política se as tarefas canceladas devem ser removidas imediatamente da fila de trabalho no momento do cancelamento.
15

void shutdown()

Inicia um desligamento ordenado no qual as tarefas enviadas anteriormente são executadas, mas nenhuma tarefa nova será aceita.
16

List<Runnable> shutdownNow()

Tenta interromper todas as tarefas em execução ativa, interrompe o processamento das tarefas em espera e retorna uma lista das tarefas que estavam aguardando execução.
17

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

Envia uma tarefa de retorno de valor para execução e retorna um Future que representa os resultados pendentes da tarefa.
18

Future<?> submit(Runnable task)

Envia uma tarefa Executável para execução e retorna um Future que representa essa tarefa.
19

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

Envia uma tarefa Executável para execução e retorna um Future que representa essa tarefa.

Exemplo

O seguinte programa TestThread mostra o uso da interface ScheduledThreadPoolExecutor em ambiente baseado em thread.

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");      
      }
   }
}

Isso produzirá o seguinte resultado.

Resultado

beep
beep
beep
beep