How to prevent a memory leak in quartz

Question

I\'m using quartz in my project. My web application has apparently caused a memory leak when it stops, the error is :

SEVERE: A web application appears to have          


        

Answer 1

By implementing org.quartz.InterruptableJob you can properly interrupt threads triggered by servlet unloading.

@DisallowConcurrentExecution
public class Job implements InterruptableJob {

    private Thread thread;

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        thread = Thread.currentThread();
        // ... do work
    }

    @Override
    public void interrupt() throws UnableToInterruptJobException {
        thread.interrupt();
        try {
            thread.join();
        } catch (InterruptedException e) {
            throw new UnableToInterruptJobException(e);
        } finally {
            // ... do cleanup
        }
    }
}

This example may cause a race condition bug on the thread variable, if the job has not been executed before it is interrupted. I leave the final solution open for suggestions, depending on the life cycle of the target application. If you need concurrent execution through the same job instance, augment the solution to handle multiple threads and remove the @DisallowConcurrentExecution annotation.

In order for this to work the quartz property org.quartz.scheduler.interruptJobsOnShutdownWithWait must be set to true. This can be done by defining a property file for the scheduler, or by a bean references if using spring framework.

Example quartz.properties file:

org.quartz.scheduler.interruptJobsOnShutdownWithWait=true

Note that the interruption only is dispatched if the scheduler is configured to wait on shutdown, resulting in a call to scheduler.shutdown(true).

Answer 2

I think you want:

     <init-param>
         <param-name>wait-on-shutdown</param-name>
         <param-value>true</param-value>
     </init-param>

You have a "quartz:" prefix which may be causing Quartz to revert to the default value of "false" for that configuration setting.

Answer 3

If you are using your own implementation of the ServletContextListener interface for your web application, you can shutdown Quartz gracefully in the contextDestroyed method. Please find below the sample code for Quartz version 2.1.7.

Your job:

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class CronJob implements Job {
    public void execute(JobExecutionContext context)
            throws JobExecutionException {
        // TODO: do you job
    }
}

Your job scheduler:

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class CronJobScheduler {

    private static CronJobScheduler instance = new CronJobScheduler();  
    private Scheduler scheduler;

    private CronJobScheduler() {    
        try {
            scheduler = new StdSchedulerFactory().getScheduler();
        } catch (SchedulerException e) {
            // TODO
        }
    }

    public static CronJobScheduler getInstance() {
        return instance;
    }

    public void trigger() {
        JobKey jobKey = JobKey.jobKey("myJobName", "myJobGroup");       
        JobDetail job = JobBuilder.newJob(CronJob.class).withIdentity(jobKey).build();

        Trigger trigger = TriggerBuilder
                .newTrigger()
                .withIdentity("myTriggerName", "myJobGroup")
                .withSchedule(CronScheduleBuilder.cronSchedule("0 0 1,13 * * ?"))
                .build();

        try {
            scheduler.start();
            scheduler.scheduleJob(job, trigger);
        } catch (SchedulerException e) {    
            // TODO
        }
    }

    public void shutdown(boolean waitForJobsToComplete) {
        try {
            scheduler.shutdown(waitForJobsToComplete);
        } catch (SchedulerException e) {
            // TODO
        }
    }

}

Your implementation of the ServletContextListener interface:

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class MyServletContextListener implements ServletContextListener {

    @Override
    public void contextDestroyed(ServletContextEvent arg0) {
        CronJobScheduler.getInstance().shutdown(true);
    }

    @Override
    public void contextInitialized(ServletContextEvent arg0) {
        CronJobScheduler.getInstance().trigger();
    }

}

Your web.xml

<listener>
    <listener-class>my.package.name.MyServletContextListener</listener-class>
</listener>

Answer 4

I see you initialize two instances... - first through org.quartz.ee.servlet.QuartzInitializerServlet - second through org.quartz.ee.servlet.QuartzInitializerListener

Either remove QuartzInitializerServlet or QuartzInitializerListener (and also corresponding parameters)... If you want to have multiple instances (for specific reasons), go with the QuartzInitializerServlet (and do not forget to use different per instance)