que diferença entre a taxa fixa e o atraso fixo na primavera do calendário?
estou a implementar tarefas agendadas usando a mola e vejo que tenho 2 tipos de tempo de configuração que funciona novamente a partir do mais recente. Que diferença entre 2 tipos esta configuração.
@Scheduled(fixedDelay = 5000)
public void doJobDelay() {
// do anything
}
@Scheduled(fixedRate = 5000)
public void doJobRate() {
// do anything
}
5 answers
- taxa fixa: faz com que a Primavera execute a tarefa em intervalos periódicos, mesmo que a a última invocação ainda pode estar em execução.
- fixedDelay: controla especificamente o tempo de execução seguinte quando o a última execução terminou.
Em código:
@Scheduled(fixedDelay=5000)
public void updateEmployeeInventory(){
System.out.println("employee inventory will be updated once only the last updated finished ");
/**
* add your scheduled job logic here
*/
}
@Scheduled(fixedRate=5000)
public void updateEmployeeInventory(){
System.out.println("employee inventory will be updated every 5 seconds from prior updated has stared, regardless it is finished or not");
/**
* add your scheduled job logic here
*/
}
FixedRate: é usado para executar o método de trabalho em cada n milisegundos. Não importa se o trabalho já terminou a sua tarefa anterior.
FixedDelay: é usado para executar o método de trabalho sequencialmente com o tempo de espera de N milisegundos dado entre as tarefas.
Quando utilizar "fixedrato": fixedRate é apropriado se não for esperado exceder o tamanho da memória e do conjunto de fios. Se as tarefas recebidas não terminarem rápido, pode acabar com "excepção de Memória"
Quando utilizar "fixedDelay": Se todas as tarefas em execução forem relevantes umas para as outras e tiverem de esperar antes de terminar a anterior, fixedRate é adequada. Se o tempo do fixedDelay for definido com cuidado, também irá permitir que os tópicos em execução tenham tempo suficiente para terminar as suas tarefas antes do início da nova tarefa
"taxa fixa": espera por X Milis desde o início da execução anterior antes de iniciar a próxima execução. Se a execução corrente exceder o intervalo 'fixedRate', a execução seguinte é em fila de espera, mas apenas a próxima. Não criará uma série de execuções em fila de espera
private static int i = 0;
@Scheduled(initialDelay=1000, fixedRate=1000)
public void testScheduling() throws InterruptedException {
System.out.println("Started : "+ ++i);
Thread.sleep(4000);
System.out.println("Finished : "+ i);
}
resultado:
Iniciado: 1
Terminado: 1 / / após 4 segundos
Iniciado: 2/ / w / o imediatamente à espera de 1 segundo, conforme especificado na taxa fixa
Terminado: 2 / / Após 4 segundos
e assim por diante
"fixedDelay": espera por X millis do final da execução anterior antes de iniciar a próxima execução. Não importa quanto tempo a execução atual está tomando, a próxima execução é iniciada depois de adicionar o intervalo 'fixedDelay' para a hora final da execução atual. Ele não vai fazer fila na próxima execução.
private static int i = 0;
@Scheduled(initialDelay=1000, fixedDelay=1000)
public void testScheduling() throws InterruptedException {
System.out.println("Started : "+ ++i);
Thread.sleep(4000);
System.out.println("Finished : "+ i);
}
resultado:
Iniciado: 1
Terminado: 1 / / após 4 segundos iniciados : 2 / / espera por 1 segundo, conforme especificado em fixedDelay Terminado: 2 / / Após 4 segundos Iniciado: 3 / / após 1 segundo
e assim por diante
Atraso fixo : controla especificamente o próximo tempo de execução quando a última execução terminar.
Taxa fixa: faz com que a Primavera execute a tarefa em intervalos periódicos, mesmo que a última invocação ainda esteja em execução.
Uma coisa que deve ser esclarecida é que fixedRate não significa que as execuções comecem com um certo intervalo de tempo.
Se um custo de execução for demasiado tempo (mais do que a taxa fixa), a execução seguinte só começará depois de o anterior terminar, a menos que @Async e @EnableAsync sejam fornecidos. Os seguintes códigos-fonte que fazem parte da implementação da Primavera ThreadPoolTaskScheduler explicam porquê:
@Override
public void run() {
Date actualExecutionTime = new Date();
super.run();
Date completionTime = new Date();
synchronized (this.triggerContextMonitor) {
this.triggerContext.update(this.scheduledExecutionTime, actualExecutionTime, completionTime);
if (!this.currentFuture.isCancelled()) {
schedule();
}
}
}
Você pode ver que só depois da tarefa anterior estar terminada (super.run()), a próxima tarefa está agendada (schedule()). Com @Async e @EnableAsync, super.run() é uma função async que retornará imediatamente, portanto a próxima tarefa não tem que esperar que a anterior realmente termine.