web-dev-qa-db-fra.com

quelle différence entre le taux fixe et le retard fixé dans le calendrier printanier?

J'implémente des tâches planifiées en utilisant spring et je vois avoir 2 types de temps de configuration qui planifiés fonctionnent à nouveau à partir de la dernière Quelle différence entre 2 tapez cette config.

 @Scheduled(fixedDelay = 5000)
    public void doJobDelay() {
        // do anything
    }
  @Scheduled(fixedRate = 5000)
    public void doJobRate() {
        // do anything
    }
javaspringscheduled-tasks
22
Adam
  • fixedRate: permet à Spring d'exécuter la tâche à intervalles réguliers, même si le dernier appel peut toujours être en cours d'exécution.
  • fixedDelay: contrôle spécifiquement la prochaine exécution à la fin de la dernière exécution

Dans du code:

@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
     */
}
24
kuhajeyan

"fixedRate": attend X millis du début de l'exécution précédente avant de commencer l'exécution suivante. Si l'exécution en cours dépasse l'intervalle 'fixedRate', la prochaine exécution est mise en file d'attente, mais seulement la suivante. Il ne créera pas de séries d'exécutions en file d'attente

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

Sortie:  

Commencé: 1
Terminé: 1 // après 4 secondes
Commencé: 2 // immédiatement sans attendre 1 seconde comme spécifié dans le forfait
Terminé: 2 // après 4 secondes
etc

"fixedDelay": attend X millis de la fin de l'exécution précédente avant de commencer l'exécution suivante. Peu importe le temps d'exécution en cours, la prochaine exécution est lancée après l'ajout de l'intervalle 'fixedDelay' à l'heure de fin de l'exécution en cours. Il ne fera pas la queue lors de la prochaine exécution.

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

Sortie:  

Commencé: 1
Terminé: 1 // après 4 secondes Commencé: 2 // attend 1 seconde comme spécifié dans fixedDelay Terminé: 2 // après 4 secondes Commencé: 3 // après 1 seconde
etc

11
nikhil7610

fixedRate: Il est utilisé pour exécuter la méthode de travail toutes les n millisecondes. Peu importe que le travail ait déjà terminé sa tâche précédente.

fixedDelay: Il est utilisé pour exécuter la méthode de travail de manière séquentielle avec le délai d'attente donné de n millisecondes entre les tâches.

Quand utiliser"fixedRate": FixedRate est approprié s'il ne devrait pas dépasser la taille de la mémoire et du pool de threads. Si les tâches entrantes ne se terminent pas rapidement, il risque de se retrouver avec "Exception de mémoire insuffisante"

Quand utiliser"fixedDelay": Si chaque tâche en cours est pertinente et si elle doit attendre avant la fin de la précédente, fixedDelay convient. Si fixedDelay time est défini avec soin, les threads en cours disposeront également de suffisamment de temps pour terminer leurs travaux avant le début de la nouvelle tâche.

7
ahmetcetin

Une chose à clarifier est que fixedRate ne signifie pas que les exécutions vont commencer à un certain intervalle de temps. 

Si une exécution coûte trop de temps (plus que le taux fixe), la prochaine exécution ne démarrera queAPRÈS LA FIN DE, à moins que @Async et @EnableAsync soient fournis. Les codes source suivants, qui font partie de l'implémentation ThreadPoolTaskScheduler de Spring, expliquent pourquoi:

@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();
        }
    }
}

Vous pouvez constater que la tâche suivante est planifiée (super.run()) uniquement lorsque la tâche précédente est terminée (schedule()). Avec @Async et @EnableAsync, super.run() est une fonction asynchrone qui sera renvoyée immédiatement. Ainsi, la tâche suivante ne doit pas nécessairement attendre la fin de la tâche précédente. 

0
fifman

Délai fixe : contrôle spécifiquement la prochaine heure d'exécution à la fin de la dernière exécution.

Fixed Rate : permet à Spring d'exécuter la tâche à intervalles réguliers, même si la dernière invocation est toujours en cours d'exécution.

0
Jinen Kothari