Outro tipo de pool de tarefas é o pool de tarefas agendadas. A julgar pelo nome, podemos supor que usamos esse tipo para agendar quando uma determinada tarefa deve ser iniciada.

Este tipo de serviço é útil quando temos uma tarefa para lançar uma atividade depois de decorrido algum tempo ou queremos agendar uma tarefa recorrente.

Para usar um, chamamos Executors.newScheduledThreadPool(1) .

Falaremos sobre os parâmetros um pouco mais tarde. Mas, por enquanto, o que precisamos saber é que, quando esse método é chamado, obtemos um objeto ScheduledExecutorService .

ScheduledExecutorService é uma interface que estende ExecutorService .

Os seguintes métodos aparecem nesta interface:

Método Explicação 

ScheduledFuture<?>
schedule(Runnable command,
                                  long delay, TimeUnit unit);
Cria e executa uma ação única que é executada após o atraso especificado. 

<V> ScheduledFuture<V>
schedule(Callable<V> callable,
                                      long delay, TimeUnit unit);
Cria e executa umAgendadoFuturoobjeto que é executado após um atraso especificado. 

ScheduledFuture<?>
scheduleAtFixedRate(Runnable command,
                                             long initialDelay,
                                             long period,
                                             TimeUnit unit);
Cria e executa uma ação recorrente que é executada primeiro após o atraso inicial especificado e, em seguida, novamente após o período especificado. Em outras palavras, a execução começará após initialDelay , depois initialDelay + period , depois initialDelay + 2 * period , e assim por diante. 

ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                long initialDelay,
                                                long delay,
                                                TimeUnit unit);
Cria e executa uma ação recorrente que é executada primeiro após o atraso inicial especificado e, em seguida, novamente com o atraso especificado entre a conclusão de uma execução e o início da próxima.
Java university

Assim, a interface nos permite executar tarefas em intervalos regulares ou após algum atraso.

Mais informações sobre o método newScheduledThreadPool.

Podemos chamá-lo de várias maneiras:


newScheduledThreadPool(int corePoolSize)
corePoolSize é o número de encadeamentos a serem mantidos no pool, mesmo que estejam ociosos. 

newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

corePoolSize é o número de encadeamentos a serem mantidos no pool, mesmo que estejam ociosos.

threadFactory é a fábrica a ser usada ao criar novos encadeamentos.

Ambos os métodos criarão um pool de threads que pode agendar ações para serem executadas após um atraso especificado ou periodicamente.

Vejamos um exemplo para ver como ScheduledThreadPool funciona.

Por exemplo, suponha que temos uma tarefa para verificar o e-mail a cada 5 segundos, mas essa verificação não deve afetar o programa principal e acarretar o consumo potencial de recursos adicionais.

Temos uma classe de tarefa que simula a verificação de e-mail.


public class Task implements Runnable {
   @Override
   public void run() {
       System.out.println("Checking email...");
   }
}

Em seguida, criamos um pool de threads e agendamos a verificação.


ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);
executorService.scheduleAtFixedRate(new Task(), 0, 5, TimeUnit.SECONDS);

Na saída, a cada 5 segundos vemos:

Verificando e-mail...

Em geral, podemos usar esse pool para realizar tarefas periódicas de "manutenção", como no exemplo. Tarefas de limpeza são tarefas que devem ser executadas independentemente do que o programa principal está fazendo.