如何在5秒内运行cron触发器超过过程

Question

我已经开发了一个我希望每5秒运行一次的工作，但可能会有某些情况下工作完成时间可能超过5秒。

我的情景：我想在0.00秒后开始工作，然后是0.05,0.10 ..但是我的下一个工作.15秒需要超过5秒才能完成工作，所以我想跳过.20秒。我想在0.25秒内触发下一个工作。

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

有两个选项：

首先是改变用于声明作业的“作业1”，而不是工作使用“StatefulJob”的接口。但是这种方式已经被弃用了。

二是宣布你的类扩展工作，但包括以下符号：

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

这可以确保作业将在同一时间只运行一次。因此，如果作业花费的时间超过5秒，那么下次运行重叠时应该预计正在进行（5秒后再次尝试）。

那么，为了响应您对使用注释的示例的请求，我在之后添加了一个。

Utilizo未PROYECTO的Java basado连接行家Ÿ英里entorno ES：

Java 8 (1.8.0-92) 
Eclipse 4.3.1 
Quartz 2.2.1 

Además，tambiénincluyo洛CON：

log4j 1.2.17 
slf4f 1.7.5 

档案馆的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> 

的主要的Java类是：

主要的Java类是：

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

作业类注释：

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

控制台输出我得到的是：

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

我觉得这确实是工作。我解释一下：

的工作必须跳每5秒，这确保基于其第一次运行建立的执行频率：

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) 

... 

因此为休息。

会发生什么情况是在常规时间运行，即如果5秒后未能尝试，如果不是，则可以始终遵守定义的范围。

事实是，我很困惑，我真的不认为我会在5秒后尝试，但根据设定的时间，它不是。