Wie Cron-Trigger mit 5 Sekunden Prozess läuft

Question

Ich habe einen Job entwickelt, den ich ausführen möchte sagen alle 5 Sekunden, aber es kann bestimmte Umstände geben, bei denen die Job-Abschlusszeit 5 Sekunden überschreiten kann.

Mein Szenario: Ich möchte einen Job bei 0,00 Sekunden starten, dann 0,05, 0,10 .. aber mein nächster Job .15 Sekunden dauert mehr als 5 Sekunden, um den Job abzuschließen, also möchte ich .20 Sek. Überspringen. Ich möchte den nächsten Job mit 0,25 Sek. Auslösen.

Scheduler sched = sf.getScheduler(); 
JobDetail job1 = JobBuilder.newJob(Job1.class).withIdentity("currentTime-Job-1", "group1").build(); 

Trigger trigger1 = TriggerBuilder.newTrigger().withIdentity("currentTime-Job-1", "group1") 
     .startAt(new Date(System.currentTimeMillis())) 
     .withSchedule(CronScheduleBuilder.cronSchedule("0/5 0/1 * 1/1 * ? *")).build(); 

sched.start(); 
sched.scheduleJob(job1, trigger1);` 

Answer 1

Es gibt zwei Möglichkeiten:

Die erstes ist die Schnittstelle zu ändern, um den Job „Job 1“ zu erklären, statt Job verwendet „StatefulJob“. Aber diese Art ist schon veraltet.

Das zweite ist, erklären Sie Ihre Klasse Job erstreckt, aber mit den folgenden Bezeichnungen:

@PersistJobDataAfterExecution 
@DisallowConcurrentExecution 
public class implements Job Job 1 { 
// You code. 
} 

Dies stellt sicher, dass der Job nur einmal zur gleichen Zeit ausgeführt werden. Wenn also die vom Job verbrachte Zeit 5 Sekunden überschreitet, sollte das nächste Mal, wenn Sie eine Überlappung ausführen, erwartet werden, dass sie ausgeführt wird (versuchen Sie es erneut 5 Sekunden später).

Nun, als Antwort auf Ihre Anfrage für ein Beispiel mit Anmerkungen, schließe ich eine nach.

Utilizo un proyecto Java basado en Maven y mi entorno es:

Java 8 (1.8.0-92) 
Eclipse 4.3.1 
Quartz 2.2.1 

Además, también incluyo loggin con:

log4j 1.2.17 
slf4f 1.7.5 

Archivo pom.xml:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 
    <modelVersion>4.0.0</modelVersion> 
    <groupId>Torren-T</groupId> 
    <artifactId>torren.t.es</artifactId> 
    <version>0.0.1-SNAPSHOT</version> 
    <dependencies> 
    <dependency> 
     <groupId>org.quartz-scheduler</groupId> 
     <artifactId>quartz</artifactId> 
     <version>2.2.1</version> 
    </dependency> 
    <dependency> 
     <groupId>log4j</groupId> 
     <artifactId>log4j</artifactId> 
     <version>1.2.17</version> 
    </dependency> 
    <dependency> 
     <groupId>org.slf4j</groupId> 
     <artifactId>slf4j-api</artifactId> 
     <version>1.7.5</version> 
    </dependency> 
    <dependency> 
     <groupId>org.slf4j</groupId> 
     <artifactId>slf4j-log4j12</artifactId> 
     <version>1.7.5</version> 
    </dependency> 
    </dependencies> 
</project> 

Die Haupt-Java-Klasse ist:

Die wichtigste Java-Klasse ist:

package torren.t.es; 

import org.apache.log4j.Logger; 
import org.quartz.Job; 

import static org.quartz.JobBuilder.newJob; 
import static org.quartz.SimpleScheduleBuilder.simpleSchedule; 

import org.quartz.JobDetail; 
import org.quartz.Scheduler; 
import org.quartz.SchedulerException; 
import org.quartz.Trigger; 

import static org.quartz.TriggerBuilder.newTrigger; 

import org.quartz.impl.StdSchedulerFactory; 


public class Terremoto { 
    public static final Logger LOGGER = Logger.getLogger(Terremoto.class); 

    private static Scheduler scheduler = null; 

    private Terremoto() { 
    } 

    private static final void dormirseNSegundos(int sleepingSeconds) { 
     try { 
      Thread.sleep((long)sleepingSeconds * (long)1000); 
     } catch (InterruptedException e) { 
      LOGGER.warn("I could not sleep"); 
      LOGGER.warn(e); 
     } 
    } 

    private static final void go(Class<? extends Job> myJob) { 
     JobDetail job; 
     final String jobName = myJob.getName(); 
     final String trgName = jobName + "Trigger"; 
     final String grpName = jobName + "Group"; 


     // The Job. 
     job = newJob(myJob).withIdentity(myJob.getName(), jobName).build(); 

     // Trigger the job to run now, and then repeat every 40 seconds 
     Trigger trigger = newTrigger() 
       .withIdentity(trgName, grpName) 
       .startNow() 
        .withSchedule(simpleSchedule() 
         .withIntervalInSeconds(5) 
         .repeatForever())    
       .build(); 

     // Tell quartz to schedule the job using our trigger 
      try { 
      scheduler.scheduleJob(job, trigger); 
     } catch (SchedulerException e) { 
      LOGGER.error("Failed initialization job"); 
      LOGGER.error(e); 
     } 
    } 

    public static final void Start() { 
     Start(-1, null); 
    } 

    public static final void Start(int sleepingSeconds) { 
     Start(sleepingSeconds, null); 
    } 

    public static final void Start(Class<? extends Job> myJob) { 
     Start(-1, myJob); 
    } 

    public static final void Start(int sleepingSeconds, Class<? extends Job> myJob) { 
     try { 
      // Grab the Scheduler instance from the Factory 
      scheduler = StdSchedulerFactory.getDefaultScheduler(); 

      // and start 
      scheduler.start(); 

      // Start job. 
      if (myJob != null) { 
       go(myJob); 
      } 

      // Going to sleep! 
      if (0 < sleepingSeconds) { 
       dormirseNSegundos(sleepingSeconds); 
      } 

      // Stop Scheduler. 
      scheduler.shutdown(); 

     } catch (SchedulerException se) { 
      LOGGER.error("Failed initialization scheduler"); 
      LOGGER.error(se); 
     } 
    } 

    public static void main(String[] args) { 
     LOGGER.info("Starting Scheduler ..."); 
     Start(60, TorrenTJob.class); 
    } 
} 

Die Jobklasse mit Anmerkungen:

package torren.t.es; 

import org.apache.log4j.Logger; 
import org.quartz.DisallowConcurrentExecution; 
import org.quartz.Job; 
import org.quartz.JobExecutionContext; 
import org.quartz.JobExecutionException; 
import org.quartz.PersistJobDataAfterExecution; 

@PersistJobDataAfterExecution 
@DisallowConcurrentExecution 
public class TorrenTJob implements Job { 

    public static final Logger LOGGER = Logger.getLogger(TorrenTJob.class); 

    public void execute(JobExecutionContext arg0) throws JobExecutionException { 
     LOGGER.info("Hello world from a TorrenTJob!"); 
    } 
} 

Console Ausgabe ich erhalte, ist:

2016-05-08 11:23:28 INFO Terremoto:104 - Iniciando Scheduler ... 
2016-05-08 11:23:28 INFO StdSchedulerFactory:1184 - Using default implementation for ThreadExecutor 
2016-05-08 11:23:28 INFO SchedulerSignalerImpl:61 - Initialized Scheduler Signaller of type: class org.quartz.core.SchedulerSignalerImpl 
2016-05-08 11:23:28 INFO QuartzScheduler:240 - Quartz Scheduler v.2.2.1 created. 
2016-05-08 11:23:28 INFO RAMJobStore:155 - RAMJobStore initialized. 
2016-05-08 11:23:28 INFO QuartzScheduler:305 - Scheduler meta-data: Quartz Scheduler (v2.2.1) 'SchTorrenT' with instanceId 'NON_CLUSTERED' 
    Scheduler class: 'org.quartz.core.QuartzScheduler' - running locally. 
    NOT STARTED. 
    Currently in standby mode. 
    Number of jobs executed: 0 
    Using thread pool 'org.quartz.simpl.SimpleThreadPool' - with 3 threads. 
    Using job-store 'org.quartz.simpl.RAMJobStore' - which does not support persistence. and is not clustered. 

2016-05-08 11:23:28 INFO StdSchedulerFactory:1339 - Quartz scheduler 'SchTorrenT' initialized from default resource file in Quartz package: 'quartz.properties' 
2016-05-08 11:23:28 INFO StdSchedulerFactory:1343 - Quartz scheduler version: 2.2.1 
2016-05-08 11:23:28 INFO QuartzScheduler:575 - Scheduler SchTorrenT_$_NON_CLUSTERED started. 
2016-05-08 11:23:28 INFO TorrenTJob:17 - Hola mundo desde un Job 

Answer 2

Ich denke, dass wirklich funktioniert. Ich erkläre:

Der Job muss alle 5 Sekunden springen, und dies sorgt für die etablierten Ausführungsfrequenz basierend auf seinem ersten Lauf:

07 May 2016 12:12:50 IST (first time and timebase for the rest). 
07 May 2016 12:12:55 IST (do not get but two seconds later) 
07 May 2016 12:13:00 IST (do not get but one second later) 

... 

Und so für den Rest.

Was passiert ist, dass läuft zu regelmäßigen Zeiten, dh, wenn es nicht versäumt, nach 5 Sekunden versuchen, wenn nicht, wenn Sie können, aber immer respektiert den definierten Bereich.

Die Wahrheit ist, dass ich verwirrt war, ich dachte nicht wirklich, dass ich nach 5 Sekunden versuchen würde, aber entsprechend der gesetzten Zeit ist es nicht.