Question

I have two processes:

Process 1 – implements runnable and can run forever.
Process 2 – fires at fixed hour and minute of day (i’ve created a job that run with Quartz).

To warn the process 1 that the other process is running I can use the TriggerListener, but how can I postpone the fire of the second process if the process 1 still doing something?

For example: I need to fire the trigger at 2PM, but this need to be done after 2PM if the process 1 isnt idle.

Here’s some sample:

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

That’s quite a common question in Quartz. Here are some hints provided by the FAQ