TOC

Um guia para o Agendador de tarefas Spring

Um guia para o Agendador de tarefas Spring

1. Visão geral

Neste artigo, discutiremos osSpring task scheduling mechanisms -TaskScheduler e suas implementações pré-construídas, juntamente com os diferentes acionadores a serem usados. Se você quiser ler mais sobre programação no Spring, verifique os artigos@Asynce@Scheduled.

TaskScheuler foi introduzido no Spring 3.0 com uma variedade de métodos para executar em algum ponto no futuro, ele também retorna um objeto de representação da interfaceScheduledFuture, que pode ser usado para cancelar a tarefa agendada ou verificar se é feito ou não.

Tudo o que precisamos fazer é selecionar uma tarefa executável para agendamento e selecionar uma política de agendamento adequada.

2. ThreadPoolTaskScheduler

ThreadPoolTaskScheduler ** é bem adequado para gerenciamento de encadeamento interno, pois delega tarefas paraScheduledExecutorServicee implementa a interfaceTaskExecutor - para que uma única instância seja capaz de lidar com execuções potenciais assíncronas, bem como a anotação@Scheduled.

Vamos agora definir o beanThreadPoolTaskScheduler emThreadPoolTaskSchedulerConfig: __ 

@Configuration
@ComponentScan(
  basePackages="org.example.taskscheduler",
  basePackageClasses={ThreadPoolTaskSchedulerExamples.class})
public class ThreadPoolTaskSchedulerConfig {

    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler(){
        ThreadPoolTaskScheduler threadPoolTaskScheduler
          = new ThreadPoolTaskScheduler();
        threadPoolTaskScheduler.setPoolSize(5);
        threadPoolTaskScheduler.setThreadNamePrefix(
          "ThreadPoolTaskScheduler");
        return threadPoolTaskScheduler;
    }
}

O beanthreadPoolTaskScheduler configurado pode executar tarefas de forma assíncrona com base no tamanho do pool configurado de 5.

Observe que todos os nomes de thread relacionados aThreadPoolTaskScheduler serão prefixados comThreadPoolTaskScheduler.

Vamos implementar uma tarefa simples que podemos agendar: 

class RunnableTask implements Runnable{
    private String message;

    public RunnableTask(String message){
        this.message = message;
    }

    @Override
    public void run() {
        System.out.println(new Date()+" Runnable Task with "+message
          +" on thread "+Thread.currentThread().getName());
    }
}

Agora podemos agendar com simplicidade esta tarefa a ser executada pelo agendador: 

taskScheduler.schedule(
  new Runnabletask("Specific time, 3 Seconds from now"),
  new Date(System.currentTimeMillis + 3000)
);

OtaskScheduler irá agendar esta tarefa executável em uma data conhecida, exatamente 3 segundos após a hora atual.

Agora vamos aprofundar um pouco mais nos mecanismos de programaçãoThreadPoolTaskScheduler.

3. Agendar tarefaRunnable com atraso fixo

O agendamento com um atraso fixo pode ser feito com dois mecanismos simples:

3.1. Agendamento após um atraso fixo da última execução agendada

Vamos configurar uma tarefa para ser executada após um atraso fixo de 1000 milissegundos: 

taskScheduler.scheduleWithFixedDelay(
  new RunnableTask("Fixed 1 second Delay"), 1000);

ORunnableTask sempre será executado 1000 milissegundos depois, entre a conclusão de uma execução e o início da próxima.

3.2. Agendamento após um atraso fixo de uma data específica

Vamos configurar uma tarefa para ser executada após um atraso fixo de um determinado horário de início: 

taskScheduler.scheduleWithFixedDelay(
  new RunnableTask("Current Date Fixed 1 second Delay"),
  new Date(),
  1000);

ORunnableTask será chamado no tempo de execução especificado, principalmente o tempo em que o método@PostConstruct inicia e, subsequentemente, com ** 1000 milissegundos de atraso.

4. Programação a uma taxa fixa

Existem dois mecanismos simples para agendar tarefas executáveis ​​a uma taxa fixa:

4.1. ProgramandoRunnableTask em uma taxa fixa

Vamos agendar uma tarefa para ser executada emfixed rate of milliseconds: 

taskScheduler.scheduleAtFixedRate(
  new RunnableTask("Fixed Rate of 2 seconds") , 2000);

O próximoRunnableTask será executado sempre após 2.000 milissegundos, não importando o status da última execução, que ainda pode estar em execução.

4.2. ProgramandoRunnableTask em uma taxa fixa a partir de uma determinada data 

taskScheduler.scheduleAtFixedRate(new RunnableTask(
  "Fixed Rate of 2 seconds"), new Date(), 3000);

ORunnableTask rodará 3.000 milissegundos após a hora atual.

5. Agendamento comCronTrigger

CronTrigger é usado para agendar uma tarefa com base em uma expressão cron: 

CronTrigger cronTrigger
  = new CronTrigger("10 * * * * ?");

O gatilho fornecido pode ser usado para executar uma tarefa de acordo com uma determinada cadência ou programação especificada: 

taskScheduler.schedule(new RunnableTask("Cron Trigger"), cronTrigger);

Neste caso, oRunnableTask será executado no décimo segundo de cada minuto.

6. Agendamento comPeriodicTrigger

Vamos usarPeriodicTrigger para agendar uma tarefa com umfixed delay de 2.000 milissegundos: 

PeriodicTrigger periodicTrigger
  = new PeriodicTrigger(2000, TimeUnit.MICROSECONDS);

O beanPeriodicTrigger configurado seria usado para executar uma tarefa após um atraso fixo de ** 2.000 milissegundos.

Agora vamos programarRunnableTask comPeriodicTrigger: 

taskScheduler.schedule(
  new RunnableTask("Periodic Trigger"), periodicTrigger);

Também podemos configurarPeriodicTrigger para ser inicializado em uma taxa fixa em vez de um atraso fixo, também podemos definir um atraso inicial para a primeira tarefa agendada em alguns milissegundos.

Tudo o que precisamos fazer é adicionar duas linhas de código antes da instrução de retorno no beanperiodicTrigger: 

periodicTrigger.setFixedRate(true);
periodicTrigger.setInitialDelay(1000);

Usamos o métodosetFixedRate para agendar a tarefa em uma taxa fixa em vez de um atraso fixo, então o métodosetInitialDelay é usado para definir o atraso inicial apenas para a primeira tarefa executável a ser executada.

7. Conclusão

Neste artigo rápido, ilustramos como agendar uma tarefa executável usando o suporte do Spring para tarefas.

Observamos a execução da tarefa com um atraso fixo, a uma taxa fixa e de acordo com um gatilho especificado.

E, como sempre, o código está disponível como um projeto Mavenover in GitHub.

Related