Question

我有两个过程：

进程1 - 实现runnable并且可以永久运行。过程2 - 在固定的小时和分钟点火（我创建了一个与Quartz一起运行的作业）。

警告进程1其他进程正在运行我可以使用TriggerListener，但如果进程1仍在执行某些操作，如何推迟第二个进程的激活？

例如：我需要在下午2点触发触发器，但是如果进程1没有空闲，则需要在下午2点之后完成。

以下是一些示例：

ProcessForever.java

import static org.quartz.CronScheduleBuilder.dailyAtHourAndMinute;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;

public class ProcessForever implements Runnable {

    private boolean processTwoRunning;
    private Scheduler scheduler;
    private Trigger trgProcessTwo;
    private String status;

    public static final STATUS_PROCESS = "PROCESS";
    public static final STATUS_SLEEP = "SLEEP";

    private static Logger LOGGER = Logger.getLogger( ProcessForever.class.getName() );

    public void init() throws SchedulerException {
        SchedulerFactory fact = new StdSchedulerFactory();
        scheduler = fact.getScheduler();
    }

    @Override
    public void run() {
        try {
          scheduler.start();
          buildTrigger();
          while( true ) {
              //do something and then sleep for some time.
              //the Quartz trigger should fire only in STATUS_SLEEP...
              setStatus( STATUS_PROCESS );      
              try { Thread.sleep(120 * 1000); }catch(Exception e){}
              setStatus( STATUS_SLEEP );        
          }catch( Exception e ) {
              e.printStackTrace();
          }
}

    private void buildTrigger() throws SchedulerException {
    LOGGER.info("defineCargaDadosTrigger()");
    JobDetail dt = newJob( ProcessTwo.class )
                             .withIdentity("coleta","grpcoleta")
                             .build();

    trgProcessTwo = newTrigger().withIdentity( 
                          new TriggerKey("triggerProcessTwo") )
                                  .forJob( dt )
                                  .startNow()
                                  .withSchedule( dailyAtHourAndMinute(13,31) )
                                  .build();
    KeyMatcher<TriggerKey> m = KeyMatcher.keyEquals( trgProcessTwo.getKey() );
    scheduler.scheduleJob(dt, trgProcessTwo );
    //this will notice the process 1 that the trigger is running...
            //scheduler.getListenerManager().addTriggerListener(someclass, m );
}

    //getters & setters ommited...

}

ProcessTwo.java

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
 /**
  ProcessTwo cannot run concurrent with ProcessForever...
  */
 public ProcessTwo implements Job {
      @Override
      public void execute(JobExecutionContext arg0) throws JobExecutionException {
          System.out.println("Doing something...");
          try { Thread.sleep(10000); } catch( InterruptedException i ){}
          System.out.println("Stop doing something...");
      }
 }

Answer 1

这在Quartz中是一个很常见的问题。以下是FAQ

提供的一些提示

有可能在Quartz中推迟触发火灾吗？

1 个答案: